From 18286fac8e7caf67008881a1445c713e51448513 Mon Sep 17 00:00:00 2001 From: Emre Kultursay Date: Thu, 26 Feb 2026 09:43:09 -0800 Subject: [PATCH 01/14] Restore python scripts --- scripts/base_generator.py | 1207 ++++++++++++++++++++++++++++++++++++ scripts/generate_source.py | 2 +- scripts/vulkan_object.py | 627 +++++++++++++++++++ 3 files changed, 1835 insertions(+), 1 deletion(-) create mode 100644 scripts/base_generator.py create mode 100644 scripts/vulkan_object.py diff --git a/scripts/base_generator.py b/scripts/base_generator.py new file mode 100644 index 0000000000..c1b04c126d --- /dev/null +++ b/scripts/base_generator.py @@ -0,0 +1,1207 @@ +#!/usr/bin/env python3 -i +# +# Copyright 2023-2025 The Khronos Group Inc. +# +# SPDX-License-Identifier: Apache-2.0 + +import pickle +import os +import tempfile +import copy +from vulkan_object import (VulkanObject, + Extension, Version, Deprecate, Handle, FuncPointerParam, FuncPointer, Param, Queues, CommandScope, Command, + EnumField, Enum, Flag, Bitmask, ExternSync, Flags, Member, Struct, + Constant, FormatComponent, FormatPlane, Format, FeatureRequirement, + SyncSupport, SyncEquivalent, SyncStage, SyncAccess, SyncPipelineStage, SyncPipeline, + SpirvEnables, Spirv, + VideoCodec, VideoFormat, VideoProfiles, VideoProfileMember, VideoRequiredCapabilities, + VideoStd, VideoStdHeader) + +# These live in the Vulkan-Docs repo, but are pulled in via the +# Vulkan-Headers/registry folder +from generator import OutputGenerator, GeneratorOptions, write +from vkconventions import VulkanConventions +from reg import Registry +from xml.etree import ElementTree + +# An API style convention object +vulkanConventions = VulkanConventions() + +# Helpers to keep things cleaner +def splitIfGet(elem, name): + return elem.get(name).split(',') if elem.get(name) is not None and elem.get(name) != '' else [] + +def textIfFind(elem, name): + return elem.find(name).text if elem.find(name) is not None else None + +def intIfGet(elem, name): + return None if elem.get(name) is None else int(elem.get(name), 0) + +def boolGet(elem, name) -> bool: + return elem.get(name) is not None and elem.get(name) == "true" + +def externSyncGet(elem): + value = elem.get('externsync') + if value is None: + return (ExternSync.NONE, None) + if value == 'true': + return (ExternSync.ALWAYS, None) + if value == 'maybe': + return (ExternSync.MAYBE, None) + + # There are no cases where multiple members of the param are marked as + # externsync. Supporting that with maybe: requires more than + # ExternSync.SUBTYPE_MAYBE (which is only one bit of information), which is + # not currently done as there are no users. + # + # If this assert is hit, please consider simplifying the design such that + # externsync can move to the struct itself and so external synchronization + # requirements do not depend on the context. + assert ',' not in value + + if value.startswith('maybe:'): + return (ExternSync.SUBTYPE_MAYBE, value.removeprefix('maybe:')) + return (ExternSync.SUBTYPE, value) + + +def getQueues(elem) -> Queues: + queues = 0 + queues_list = splitIfGet(elem, 'queues') + if len(queues_list) > 0: + queues |= Queues.TRANSFER if 'transfer' in queues_list else 0 + queues |= Queues.GRAPHICS if 'graphics' in queues_list else 0 + queues |= Queues.COMPUTE if 'compute' in queues_list else 0 + queues |= Queues.PROTECTED if 'protected' in queues_list else 0 + queues |= Queues.SPARSE_BINDING if 'sparse_binding' in queues_list else 0 + queues |= Queues.OPTICAL_FLOW if 'opticalflow' in queues_list else 0 + queues |= Queues.DECODE if 'decode' in queues_list else 0 + queues |= Queues.ENCODE if 'encode' in queues_list else 0 + queues |= Queues.DATA_GRAPH if 'data_graph' in queues_list else 0 + return queues + +# Shared object used by Sync elements that do not have ones +maxSyncSupport = SyncSupport(None, None, True) +maxSyncEquivalent = SyncEquivalent(None, None, True) + +# Helpers to set GeneratorOptions options globally +def SetOutputFileName(fileName: str) -> None: + global globalFileName + globalFileName = fileName + +def SetOutputDirectory(directory: str) -> None: + global globalDirectory + globalDirectory = directory + +def SetTargetApiName(apiname: str) -> None: + global globalApiName + globalApiName = apiname + +def SetMergedApiNames(names: str) -> None: + global mergedApiNames + mergedApiNames = names + +cachingEnabled = False +def EnableCaching() -> None: + global cachingEnabled + cachingEnabled = True + +# This class is a container for any source code, data, or other behavior that is necessary to +# customize the generator script for a specific target API variant (e.g. Vulkan SC). As such, +# all of these API-specific interfaces and their use in the generator script are part of the +# contract between this repository and its downstream users. Changing or removing any of these +# interfaces or their use in the generator script will have downstream effects and thus +# should be avoided unless absolutely necessary. +class APISpecific: + # Version object factory method + @staticmethod + def createApiVersion(targetApiName: str, name: str, featureRequirement) -> Version: + match targetApiName: + + # Vulkan SC specific API version creation + case 'vulkansc': + nameApi = name.replace('VK_', 'VK_API_') + nameApi = nameApi.replace('VKSC_', 'VKSC_API_') + nameString = f'"{name}"' + return Version(name, nameString, nameApi, featureRequirement) + + # Vulkan specific API version creation + case 'vulkan': + nameApi = name.replace('VK_', 'VK_API_') + nameString = f'"{name}"' + return Version(name, nameString, nameApi, featureRequirement) + + # TODO - Currently genType in reg.py does not provide a good way to get this string to apply the C-macro + # We do our best to emulate the answer here the way the spec/headers will with goal to have a proper fix before these assumptions break + @staticmethod + def createHeaderVersion(targetApiName: str, vk: VulkanObject) -> str: + match targetApiName: + case 'vulkan': + major_version = 1 + minor_version = 4 + case 'vulkansc': + major_version = 1 + minor_version = 0 + return f'{major_version}.{minor_version}.{vk.headerVersion}' + + +# This Generator Option is used across all generators. +# After years of use, it has shown that most the options are unified across each generator (file) +# as it is easier to modify things per-file that need the difference +class BaseGeneratorOptions(GeneratorOptions): + def __init__(self, + customFileName = None, + customDirectory = None, + customApiName = None, + videoXmlPath = None): + GeneratorOptions.__init__(self, + conventions = vulkanConventions, + filename = customFileName if customFileName else globalFileName, + directory = customDirectory if customDirectory else globalDirectory, + apiname = customApiName if customApiName else globalApiName, + mergeApiNames = mergedApiNames, + defaultExtensions = customApiName if customApiName else globalApiName, + emitExtensions = '.*', + emitSpirv = '.*', + emitFormats = '.*') + # These are used by the generator.py script + self.apicall = 'VKAPI_ATTR ' + self.apientry = 'VKAPI_CALL ' + self.apientryp = 'VKAPI_PTR *' + self.alignFuncParam = 48 + + # This is used to provide the video.xml to the private video XML generator + self.videoXmlPath = videoXmlPath + +# +# This object handles all the parsing from reg.py generator scripts in the Vulkan-Headers +# It will grab all the data and form it into a single object the rest of the generators will use +class BaseGenerator(OutputGenerator): + def __init__(self): + OutputGenerator.__init__(self, None, None, None) + self.vk = VulkanObject() + self.targetApiName = globalApiName + + # reg.py has a `self.featureName` but this is nicer because + # it will be either the Version or Extension object + self.currentExtension = None + self.currentVersion = None + + # We need to flag extensions that we ignore because they are disabled or not + # supported in the target API(s) + self.unsupportedExtension = False + + # Will map alias to promoted name + # ex. ['VK_FILTER_CUBIC_IMG' : 'VK_FILTER_CUBIC_EXT'] + # When generating any code, there is no reason so use the old name + self.enumAliasMap = dict() + self.enumFieldAliasMap = dict() + self.bitmaskAliasMap = dict() + self.flagAliasMap = dict() + self.flagsAliasMap = dict() + self.structAliasMap = dict() + self.handleAliasMap = dict() + + # We track all enum constants and flag bits so that we can apply their aliases in the end + self.enumFieldMap: dict[str, EnumField] = dict() + self.flagMap: dict[str, Flag] = dict() + + # De-aliases a definition name based on the specified alias map. + # There are aliases of aliases. + # e.g. VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR aliases + # VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR which itself aliases + # But it is also common for EXT types promoted to KHR then to core. + # We should not make assumptions about the nesting level of aliases, instead we resolve any + # level of alias aliasing. + def dealias(self, name: str, aliasMap: dict): + while name in aliasMap: + name = aliasMap[name] + return name + + def write(self, data): + # Prevents having to check before writing + if data is not None and data != "": + write(data, file=self.outFile) + + def beginFile(self, genOpts): + OutputGenerator.beginFile(self, genOpts) + self.filename = genOpts.filename + + # No gen*() command to get these, so do it manually + for platform in self.registry.tree.findall('platforms/platform'): + self.vk.platforms[platform.get('name')] = platform.get('protect') + + for tags in self.registry.tree.findall('tags'): + for tag in tags.findall('tag'): + self.vk.vendorTags.append(tag.get('name')) + + # No way known to get this from the XML + self.vk.queueBits[Queues.TRANSFER] = 'VK_QUEUE_TRANSFER_BIT' + self.vk.queueBits[Queues.GRAPHICS] = 'VK_QUEUE_GRAPHICS_BIT' + self.vk.queueBits[Queues.COMPUTE] = 'VK_QUEUE_COMPUTE_BIT' + self.vk.queueBits[Queues.PROTECTED] = 'VK_QUEUE_PROTECTED_BIT' + self.vk.queueBits[Queues.SPARSE_BINDING] = 'VK_QUEUE_SPARSE_BINDING_BIT' + self.vk.queueBits[Queues.OPTICAL_FLOW] = 'VK_QUEUE_OPTICAL_FLOW_BIT_NV' + self.vk.queueBits[Queues.DECODE] = 'VK_QUEUE_VIDEO_DECODE_BIT_KHR' + self.vk.queueBits[Queues.ENCODE] = 'VK_QUEUE_VIDEO_ENCODE_BIT_KHR' + self.vk.queueBits[Queues.DATA_GRAPH] = 'VK_QUEUE_DATA_GRAPH_BIT_ARM' + + # If the video.xml path is provided then we need to load and parse it using + # the private video std generator + if genOpts.videoXmlPath is not None: + videoStdGenerator = _VideoStdGenerator() + videoRegistry = Registry(videoStdGenerator, genOpts) + videoRegistry.loadElementTree(ElementTree.parse(genOpts.videoXmlPath)) + videoRegistry.apiGen() + self.vk.videoStd = videoStdGenerator.vk.videoStd + + # This function should be overloaded + def generate(self): + print("WARNING: This should not be called from the child class") + return + + # This function is dense, it does all the magic to set the right extensions dependencies! + # + # The issue is if 2 extension expose a command, genCmd() will only + # show one of the extension, at endFile() we can finally go through + # and update which things depend on which extensions + # + # self.featureDictionary is built for use in the reg.py framework + # Details found in Vulkan-Docs/scripts/scriptgenerator.py + def applyExtensionDependency(self): + for extension in self.vk.extensions.values(): + # dict.key() can be None, so need to double loop + dict = self.featureDictionary[extension.name]['command'] + + # "required" == None + # or + # an additional feature dependency, which is a boolean expression of + # one or more extension and/or core version names + for required in dict: + for commandName in dict[required]: + # Skip commands removed in the target API + # This check is needed because parts of the base generator code bypass the + # dependency resolution logic in the registry tooling and thus the generator + # may attempt to generate code for commands which are not supported in the + # target API variant, thus this check needs to happen even if any specific + # target API variant may not specifically need it + if not commandName in self.vk.commands: + continue + + command = self.vk.commands[commandName] + # Make sure list is unique + command.extensions.extend([extension.name] if extension.name not in command.extensions else []) + extension.commands.extend([command] if command not in extension.commands else []) + + # While genGroup() will call twice with aliased value, it does not provide all the information we need + dict = self.featureDictionary[extension.name]['enumconstant'] + for required in dict: + # group can be a Enum or Bitmask + for group in dict[required]: + if group in self.vk.handles: + handle = self.vk.handles[group] + # Make sure list is unique + handle.extensions.extend([extension.name] if extension.name not in handle.extensions else []) + extension.handles[group].extend([handle] if handle not in extension.handles[group] else []) + if group in self.vk.enums: + if group not in extension.enumFields: + extension.enumFields[group] = [] # Dict needs init + enum = self.vk.enums[group] + # Need to convert all alias so they match what is in EnumField + enumList = list(map(lambda x: x if x not in self.enumFieldAliasMap else self.dealias(x, self.enumFieldAliasMap), dict[required][group])) + + for enumField in [x for x in enum.fields if x.name in enumList]: + # Make sure list is unique + enum.fieldExtensions.extend([extension.name] if extension.name not in enum.fieldExtensions else []) + enumField.extensions.extend([extension.name] if extension.name not in enumField.extensions else []) + extension.enumFields[group].extend([enumField] if enumField not in extension.enumFields[group] else []) + if group in self.vk.bitmasks: + if group not in extension.flagBits: + extension.flagBits[group] = [] # Dict needs init + bitmask = self.vk.bitmasks[group] + # Need to convert all alias so they match what is in Flags + flagList = list(map(lambda x: x if x not in self.flagAliasMap else self.dealias(x, self.flagAliasMap), dict[required][group])) + + for flags in [x for x in bitmask.flags if x.name in flagList]: + # Make sure list is unique + bitmask.flagExtensions.extend([extension.name] if extension.name not in bitmask.flagExtensions else []) + flags.extensions.extend([extension.name] if extension.name not in flags.extensions else []) + extension.flagBits[group].extend([flags] if flags not in extension.flagBits[group] else []) + if group in self.vk.flags: + flags = self.vk.flags[group] + # Make sure list is unique + flags.extensions.extend([extension.name] if extension.name not in flags.extensions else []) + extension.flags.extend([flags] if flags not in extension.flags[group] else []) + + # Need to do 'enum'/'bitmask' after 'enumconstant' has applied everything so we can add implicit extensions + # + # Sometimes two extensions enable an Enum, but the newer extension version has extra flags allowed + # This information seems to be implicit, so need to update it here + # Go through each Flag and append the Enum extension to it + # + # ex. VkAccelerationStructureTypeKHR where GENERIC_KHR is not allowed with just VK_NV_ray_tracing + # This only works because the values are aliased as well, making the KHR a superset enum + for extension in self.vk.extensions.values(): + dict = self.featureDictionary[extension.name]['enum'] + for required in dict: + for group in dict[required]: + for enumName in dict[required][group]: + isAlias = enumName in self.enumAliasMap + enumName = self.dealias(enumName, self.enumAliasMap) + if enumName in self.vk.enums: + enum = self.vk.enums[enumName] + enum.extensions.extend([extension.name] if extension.name not in enum.extensions else []) + extension.enums.extend([enum] if enum not in extension.enums else []) + # Update fields with implicit base extension + if isAlias: + continue + enum.fieldExtensions.extend([extension.name] if extension.name not in enum.fieldExtensions else []) + for enumField in [x for x in enum.fields if (not x.extensions or (x.extensions and all(e in enum.extensions for e in x.extensions)))]: + enumField.extensions.extend([extension.name] if extension.name not in enumField.extensions else []) + if enumName not in extension.enumFields: + extension.enumFields[enumName] = [] # Dict needs init + extension.enumFields[enumName].extend([enumField] if enumField not in extension.enumFields[enumName] else []) + + dict = self.featureDictionary[extension.name]['bitmask'] + for required in dict: + for group in dict[required]: + for bitmaskName in dict[required][group]: + bitmaskName = bitmaskName.replace('Flags', 'FlagBits') # Works since Flags is not repeated in name + isAlias = bitmaskName in self.bitmaskAliasMap + bitmaskName = self.dealias(bitmaskName, self.bitmaskAliasMap) + if bitmaskName in self.vk.bitmasks: + bitmask = self.vk.bitmasks[bitmaskName] + bitmask.extensions.extend([extension.name] if extension.name not in bitmask.extensions else []) + extension.bitmasks.extend([bitmask] if bitmask not in extension.bitmasks else []) + # Update flags with implicit base extension + if isAlias: + continue + bitmask.flagExtensions.extend([extension.name] if extension.name not in bitmask.flagExtensions else []) + for flag in [x for x in bitmask.flags if (not x.extensions or (x.extensions and all(e in bitmask.extensions for e in x.extensions)))]: + flag.extensions.extend([extension.name] if extension.name not in flag.extensions else []) + if bitmaskName not in extension.flagBits: + extension.flagBits[bitmaskName] = [] # Dict needs init + extension.flagBits[bitmaskName].extend([flag] if flag not in extension.flagBits[bitmaskName] else []) + + # Some structs (ex VkAttachmentSampleCountInfoAMD) can have multiple alias pointing to same extension + for extension in self.vk.extensions.values(): + dict = self.featureDictionary[extension.name]['struct'] + for required in dict: + for group in dict[required]: + for structName in dict[required][group]: + isAlias = structName in self.structAliasMap + structName = self.dealias(structName, self.structAliasMap) + if structName in self.vk.structs: + struct = self.vk.structs[structName] + struct.extensions.extend([extension.name] if extension.name not in struct.extensions else []) + + # While we update struct alias inside other structs, the command itself might have the struct as a first level param. + # We use this time to update params to have the promoted name + # Example - https://github.com/KhronosGroup/Vulkan-ValidationLayers/issues/9322 + # TODO: It is unclear why only structs need dealiasing here, but not other types, so this probably needs revisiting + for command in self.vk.commands.values(): + for member in command.params: + if member.type in self.structAliasMap: + member.type = self.dealias(member.type, self.structAliasMap) + # Replace string with Version class now we have all version created + if command.deprecate and command.deprecate.version: + if command.deprecate.version not in self.vk.versions: + # occurs if something like VK_VERSION_1_0, in which case we will always warn for deprecation + command.deprecate.version = None + else: + command.deprecate.version = self.vk.versions[command.deprecate.version] + + # Could build up a reverse lookup map, but since these are not too large of list, just do here + # (Need to be done after we have found all the aliases) + for key, value in self.structAliasMap.items(): + self.vk.structs[self.dealias(value, self.structAliasMap)].aliases.append(key) + for key, value in self.enumFieldAliasMap.items(): + self.enumFieldMap[self.dealias(value, self.enumFieldAliasMap)].aliases.append(key) + for key, value in self.enumAliasMap.items(): + self.vk.enums[self.dealias(value, self.enumAliasMap)].aliases.append(key) + for key, value in self.flagAliasMap.items(): + self.flagMap[self.dealias(value, self.flagAliasMap)].aliases.append(key) + for key, value in self.bitmaskAliasMap.items(): + self.vk.bitmasks[self.dealias(value, self.bitmaskAliasMap)].aliases.append(key) + for key, value in self.flagsAliasMap.items(): + self.vk.flags[self.dealias(value, self.flagsAliasMap)].aliases.append(key) + for key, value in self.handleAliasMap.items(): + self.vk.handles[self.dealias(value, self.handleAliasMap)].aliases.append(key) + + def addConstants(self, constantNames: list[str]): + for constantName in constantNames: + enumInfo = self.registry.enumdict[constantName] + typeName = enumInfo.type + valueStr = enumInfo.elem.get('value') + # These values are represented in c-style + isHex = valueStr.upper().startswith('0X') + intBase = 16 if isHex else 10 + if valueStr.upper().endswith('F') and not isHex: + value = float(valueStr[:-1]) + elif valueStr.upper().endswith('U)'): + inner_number = int(valueStr.removeprefix("(~").removesuffix(")")[:-1], intBase) + value = (~inner_number) & ((1 << 32) - 1) + elif valueStr.upper().endswith('ULL)'): + inner_number = int(valueStr.removeprefix("(~").removesuffix(")")[:-3], intBase) + value = (~0) & ((1 << 64) - 1) + else: + value = int(valueStr, intBase) + self.vk.constants[constantName] = Constant(constantName, typeName, value, valueStr) + + def addVideoCodecs(self): + for xmlVideoCodec in self.registry.tree.findall('videocodecs/videocodec'): + name = xmlVideoCodec.get('name') + extend = xmlVideoCodec.get('extend') + value = xmlVideoCodec.get('value') + + profiles: dict[str, VideoProfiles] = {} + capabilities: dict[str, str] = {} + formats: dict[str, VideoFormat] = {} + + if extend is not None: + # Inherit base profiles, capabilities, and formats + profiles = copy.deepcopy(self.vk.videoCodecs[extend].profiles) + capabilities = copy.deepcopy(self.vk.videoCodecs[extend].capabilities) + formats = copy.deepcopy(self.vk.videoCodecs[extend].formats) + + for xmlVideoProfiles in xmlVideoCodec.findall('videoprofiles'): + videoProfileStructName = xmlVideoProfiles.get('struct') + videoProfileStructMembers : dict[str, VideoProfileMember] = {} + + for xmlVideoProfileMember in xmlVideoProfiles.findall('videoprofilemember'): + memberName = xmlVideoProfileMember.get('name') + memberValues: dict[str, str] = {} + + for xmlVideoProfile in xmlVideoProfileMember.findall('videoprofile'): + memberValues[xmlVideoProfile.get('value')] = xmlVideoProfile.get('name') + + videoProfileStructMembers[memberName] = VideoProfileMember(memberName, memberValues) + + profiles[videoProfileStructName] = VideoProfiles(videoProfileStructName, videoProfileStructMembers) + + for xmlVideoCapabilities in xmlVideoCodec.findall('videocapabilities'): + capabilities[xmlVideoCapabilities.get('struct')] = xmlVideoCapabilities.get('struct') + + for xmlVideoFormat in xmlVideoCodec.findall('videoformat'): + videoFormatName = xmlVideoFormat.get('name') + videoFormatExtend = xmlVideoFormat.get('extend') + + videoFormatRequiredCaps: list[VideoRequiredCapabilities] = [] + videoFormatProps: dict[str, str] = {} + + if videoFormatName is not None: + # This is a new video format category + videoFormatUsage = xmlVideoFormat.get('usage') + videoFormat = VideoFormat(videoFormatName, videoFormatUsage, videoFormatRequiredCaps, videoFormatProps) + formats[videoFormatName] = videoFormat + else: + # This is an extension to an already defined video format category + videoFormat = formats[videoFormatExtend] + videoFormatRequiredCaps = videoFormat.requiredCaps + videoFormatProps = videoFormat.properties + + for xmlVideoFormatRequiredCap in xmlVideoFormat.findall('videorequirecapabilities'): + requiredCap = VideoRequiredCapabilities(xmlVideoFormatRequiredCap.get('struct'), + xmlVideoFormatRequiredCap.get('member'), + xmlVideoFormatRequiredCap.get('value')) + videoFormatRequiredCaps.append(requiredCap) + + for xmlVideoFormatProperties in xmlVideoFormat.findall('videoformatproperties'): + videoFormatProps[xmlVideoFormatProperties.get('struct')] = xmlVideoFormatProperties.get('struct') + + self.vk.videoCodecs[name] = VideoCodec(name, value, profiles, capabilities, formats) + + def endFile(self): + # This is the point were reg.py has ran, everything is collected + # We do some post processing now + self.applyExtensionDependency() + + self.addConstants([k for k,v in self.registry.enumvaluedict.items() if v == 'API Constants']) + self.addVideoCodecs() + + self.vk.headerVersionComplete = APISpecific.createHeaderVersion(self.targetApiName, self.vk) + + # Use structs and commands to find which things are returnedOnly + for struct in [x for x in self.vk.structs.values() if not x.returnedOnly]: + for enum in [self.vk.enums[x.type] for x in struct.members if x.type in self.vk.enums]: + enum.returnedOnly = False + for bitmask in [self.vk.bitmasks[x.type] for x in struct.members if x.type in self.vk.bitmasks]: + bitmask.returnedOnly = False + for flags in [self.vk.flags[x.type] for x in struct.members if x.type in self.vk.flags]: + flags.returnedOnly = False + if flags.bitmaskName is not None: + self.vk.bitmasks[flags.bitmaskName].returnedOnly = False + for command in self.vk.commands.values(): + for enum in [self.vk.enums[x.type] for x in command.params if x.type in self.vk.enums]: + enum.returnedOnly = False + for bitmask in [self.vk.bitmasks[x.type] for x in command.params if x.type in self.vk.bitmasks]: + bitmask.returnedOnly = False + for flags in [self.vk.flags[x.type] for x in command.params if x.type in self.vk.flags]: + flags.returnedOnly = False + if flags.bitmaskName is not None: + self.vk.bitmasks[flags.bitmaskName].returnedOnly = False + + # Turn handle parents into pointers to classes + for handle in [x for x in self.vk.handles.values() if x.parent is not None]: + handle.parent = self.vk.handles[handle.parent] + # search up parent chain to see if instance or device + for handle in [x for x in self.vk.handles.values()]: + next_parent = handle.parent + while (not handle.instance and not handle.device): + handle.instance = next_parent.name == 'VkInstance' + handle.device = next_parent.name == 'VkDevice' + next_parent = next_parent.parent + + maxSyncSupport.stages = self.vk.bitmasks['VkPipelineStageFlagBits2'].flags + maxSyncEquivalent.accesses = self.vk.bitmasks['VkAccessFlagBits2'].flags + maxSyncEquivalent.stages = self.vk.bitmasks['VkPipelineStageFlagBits2'].flags + + # All inherited generators should run from here + self.generate() + + if cachingEnabled: + cachePath = os.path.join(tempfile.gettempdir(), f'vkobject_{os.getpid()}') + if not os.path.isfile(cachePath): + cacheFile = open(cachePath, 'wb') + pickle.dump(self.vk, cacheFile) + cacheFile.close() + + # This should not have to do anything but call into OutputGenerator + OutputGenerator.endFile(self) + + # + # Bypass the entire processing and load in the VkObject data + # Still need to handle the beingFile/endFile for reg.py + def generateFromCache(self, cacheVkObjectData, genOpts): + OutputGenerator.beginFile(self, genOpts) + self.filename = genOpts.filename + self.vk = cacheVkObjectData + self.generate() + OutputGenerator.endFile(self) + + # + # Processing point at beginning of each extension definition + def beginFeature(self, interface, emit): + OutputGenerator.beginFeature(self, interface, emit) + platform = interface.get('platform') + self.featureExtraProtec = self.vk.platforms[platform] if platform in self.vk.platforms else None + protect = self.vk.platforms[platform] if platform in self.vk.platforms else None + name = interface.get('name') + + # TODO - This is just mimicking featurerequirementsgenerator.py and works because the logic is simple enough (for now) + featureRequirement = [] + requires = interface.findall('./require') + for require in requires: + requireDepends = require.get('depends') + for feature in require.findall('./feature'): + featureStruct = feature.get('struct') + featureName = feature.get('name') + featureRequirement.append(FeatureRequirement(featureStruct, featureName, requireDepends)) + + if interface.tag == 'extension': + # Generator scripts built on BaseGenerator do not handle the `supported` attribute of extensions + # therefore historically the `generate_source.py` in individual ecosystem components hacked the + # registry by removing non-applicable or disabled extensions from the loaded XML already before + # reg.py parsed it. That broke the general behavior of reg.py for certain use cases so we now + # filter extensions here instead (after parsing) in order to no longer need the filtering hack + # in downstream `generate_source.py` scripts. + enabledApiList = [ globalApiName ] + ([] if mergedApiNames is None else mergedApiNames.split(',')) + if (sup := interface.get('supported')) is not None and all(api not in sup.split(',') for api in enabledApiList): + self.unsupportedExtension = True + return + + instance = interface.get('type') == 'instance' + device = not instance + depends = interface.get('depends') + vendorTag = interface.get('author') + platform = interface.get('platform') + provisional = boolGet(interface, 'provisional') + promotedto = interface.get('promotedto') + deprecatedby = interface.get('deprecatedby') + obsoletedby = interface.get('obsoletedby') + specialuse = splitIfGet(interface, 'specialuse') + ratifiedApis = splitIfGet(interface, 'ratified') + ratified = True if len(ratifiedApis) > 0 and self.genOpts.apiname in ratifiedApis else False + + # Not sure if better way to get this info + specVersion = self.featureDictionary[name]['enumconstant'][None][None][0] + nameString = self.featureDictionary[name]['enumconstant'][None][None][1] + + self.currentExtension = Extension(name, nameString, specVersion, instance, device, depends, vendorTag, + platform, protect, provisional, promotedto, deprecatedby, + obsoletedby, specialuse, featureRequirement, ratified) + self.vk.extensions[name] = self.currentExtension + else: # version + number = interface.get('number') + if number != '1.0': + self.currentVersion = APISpecific.createApiVersion(self.targetApiName, name, featureRequirement) + self.vk.versions[name] = self.currentVersion + + def endFeature(self): + OutputGenerator.endFeature(self) + self.currentExtension = None + self.currentVersion = None + self.unsupportedExtension = False + + # + # All from XML + def genCmd(self, cmdinfo, name, alias): + OutputGenerator.genCmd(self, cmdinfo, name, alias) + + # Do not include APIs from unsupported extensions + if self.unsupportedExtension: + return + + params = [] + for param in cmdinfo.elem.findall('param'): + paramName = param.find('name').text + paramType = textIfFind(param, 'type') + paramAlias = param.get('alias') + + cdecl = self.makeCParamDecl(param, 0) + paramFullType = ' '.join(cdecl.split()[:-1]) + pointer = '*' in cdecl or paramType.startswith('PFN_') + paramConst = 'const' in cdecl + fixedSizeArray = [x[:-1] for x in cdecl.split('[') if x.endswith(']')] + + paramNoautovalidity = boolGet(param, 'noautovalidity') + + nullTerminated = False + length = param.get('altlen') if param.get('altlen') is not None else param.get('len') + if length: + # we will either find it like "null-terminated" or "enabledExtensionCount,null-terminated" + # This finds both + nullTerminated = 'null-terminated' in length + length = length.replace(',null-terminated', '') if 'null-terminated' in length else length + length = None if length == 'null-terminated' else length + + if fixedSizeArray and not length: + length = ','.join(fixedSizeArray) + + # See Member::optional code for details of this + optionalValues = splitIfGet(param, 'optional') + optional = len(optionalValues) > 0 and optionalValues[0].lower() == "true" + optionalPointer = len(optionalValues) > 1 and optionalValues[1].lower() == "true" + + # externsync will be 'true', 'maybe', '' or 'maybe:' + (externSync, externSyncPointer) = externSyncGet(param) + + params.append(Param(paramName, paramAlias, paramType, paramFullType, paramNoautovalidity, + paramConst, length, nullTerminated, pointer, fixedSizeArray, + optional, optionalPointer, + externSync, externSyncPointer, cdecl)) + + attrib = cmdinfo.elem.attrib + alias = attrib.get('alias') + tasks = splitIfGet(attrib, 'tasks') + + queues = getQueues(attrib) + allowNoQueues = boolGet(attrib, 'allownoqueues') + successcodes = splitIfGet(attrib, 'successcodes') + errorcodes = splitIfGet(attrib, 'errorcodes') + cmdbufferlevel = attrib.get('cmdbufferlevel') + primary = cmdbufferlevel is not None and 'primary' in cmdbufferlevel + secondary = cmdbufferlevel is not None and 'secondary' in cmdbufferlevel + + renderpass = attrib.get('renderpass') + renderpass = CommandScope.NONE if renderpass is None else getattr(CommandScope, renderpass.upper()) + videocoding = attrib.get('videocoding') + videocoding = CommandScope.NONE if videocoding is None else getattr(CommandScope, videocoding.upper()) + + protoElem = cmdinfo.elem.find('proto') + returnType = textIfFind(protoElem, 'type') + + decls = self.makeCDecls(cmdinfo.elem) + cPrototype = decls[0] + cFunctionPointer = decls[1] + + deprecate = None + if cmdinfo.deprecatedlink: + deprecate = Deprecate(cmdinfo.deprecatedlink, + cmdinfo.deprecatedbyversion, # is just the string, will update to class later + cmdinfo.deprecatedbyextensions) + + protect = self.currentExtension.protect if self.currentExtension is not None else None + + # These coammds have no way from the XML to detect they would be an instance command + specialInstanceCommand = ['vkCreateInstance', 'vkEnumerateInstanceExtensionProperties','vkEnumerateInstanceLayerProperties', 'vkEnumerateInstanceVersion'] + instance = len(params) > 0 and (params[0].type == 'VkInstance' or params[0].type == 'VkPhysicalDevice' or name in specialInstanceCommand) + device = not instance + + implicitElem = cmdinfo.elem.find('implicitexternsyncparams') + implicitExternSyncParams = [x.text for x in implicitElem.findall('param')] if implicitElem else [] + + self.vk.commands[name] = Command(name, alias, protect, [], self.currentVersion, + returnType, params, instance, device, + tasks, queues, allowNoQueues, successcodes, errorcodes, + primary, secondary, renderpass, videocoding, + implicitExternSyncParams, deprecate, cPrototype, cFunctionPointer) + + # + # List the enum for the commands + # TODO - Seems empty groups like `VkDeviceDeviceMemoryReportCreateInfoEXT` do not show up in here + def genGroup(self, groupinfo, groupName, alias): + # Do not include APIs from unsupported extensions + if self.unsupportedExtension: + return + + # There can be case where the Enum/Bitmask is in a protect, but the individual + # fields also have their own protect + groupProtect = self.currentExtension.protect if hasattr(self.currentExtension, 'protect') and self.currentExtension.protect is not None else None + enumElem = groupinfo.elem + bitwidth = 32 if enumElem.get('bitwidth') is None else int(enumElem.get('bitwidth')) + fields = [] + if enumElem.get('type') == "enum": + if alias is not None: + self.enumAliasMap[groupName] = alias + return + + for elem in enumElem.findall('enum'): + fieldName = elem.get('name') + + # Do not include non-required enum constants + # reg.py emits the enum constants of the entire type, even constants that are part of unsupported + # extensions or those that are removed by elements in a given API. reg.py correctly tracks + # down these and also alias dependencies and marks the enum constants that are actually required + # with the 'required' attribute. Therefore we also have to verify that here to make sure we only + # include enum constants that are actually required in the target API(s). + if elem.get('required') is None: + continue + + if elem.get('alias') is not None: + self.enumFieldAliasMap[fieldName] = elem.get('alias') + continue + + negative = elem.get('dir') is not None + protect = elem.get('protect') + (valueInt, valueStr) = self.enumToValue(elem, True, bitwidth) + + # Some values have multiple extensions (ex VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR) + # genGroup() lists them twice + if next((x for x in fields if x.name == fieldName), None) is None: + self.enumFieldMap[fieldName] = EnumField(fieldName, [], protect, negative, valueInt, valueStr, []) + fields.append(self.enumFieldMap[fieldName]) + + self.vk.enums[groupName] = Enum(groupName, [], groupProtect, bitwidth, True, fields, [], []) + + else: # "bitmask" + if alias is not None: + self.bitmaskAliasMap[groupName] = alias + return + + for elem in enumElem.findall('enum'): + flagName = elem.get('name') + + # Do not include non-required enum constants + # reg.py emits the enum constants of the entire type, even constants that are part of unsupported + # extensions or those that are removed by elements in a given API. reg.py correctly tracks + # down these and also alias dependencies and marks the enum constants that are actually required + # with the 'required' attribute. Therefore we also have to verify that here to make sure we only + # include enum constants that are actually required in the target API(s). + if elem.get('required') is None: + continue + + if elem.get('alias') is not None: + self.flagAliasMap[flagName] = elem.get('alias') + continue + + protect = elem.get('protect') + + (valueInt, valueStr) = self.enumToValue(elem, True, bitwidth) + flagZero = valueInt == 0 + flagMultiBit = False + # if flag uses 'value' instead of 'bitpos', will be zero or a mask + if elem.get('bitpos') is None and elem.get('value'): + flagMultiBit = valueInt != 0 + + # Some values have multiple extensions (ex VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT) + # genGroup() lists them twice + if next((x for x in fields if x.name == flagName), None) is None: + self.flagMap[flagName] = Flag(flagName, [], protect, valueInt, valueStr, flagMultiBit, flagZero, []) + fields.append(self.flagMap[flagName]) + + flagName = groupName.replace('FlagBits', 'Flags') + self.vk.bitmasks[groupName] = Bitmask(groupName, [], flagName, groupProtect, bitwidth, True, fields, [], []) + + def genType(self, typeInfo, typeName, alias): + OutputGenerator.genType(self, typeInfo, typeName, alias) + + # Do not include APIs from unsupported extensions + if self.unsupportedExtension: + return + + typeElem = typeInfo.elem + protect = self.currentExtension.protect if hasattr(self.currentExtension, 'protect') and self.currentExtension.protect is not None else None + extension = [self.currentExtension.name] if self.currentExtension is not None else [] + category = typeElem.get('category') + if (category == 'struct' or category == 'union'): + if alias is not None: + self.structAliasMap[typeName] = alias + return + + union = category == 'union' + + returnedOnly = boolGet(typeElem, 'returnedonly') + allowDuplicate = boolGet(typeElem, 'allowduplicate') + + extends = splitIfGet(typeElem, 'structextends') + extendedBy = self.registry.validextensionstructs[typeName] if len(self.registry.validextensionstructs[typeName]) > 0 else [] + + membersElem = typeInfo.elem.findall('.//member') + members = [] + sType = None + + for member in membersElem: + for comment in member.findall('comment'): + member.remove(comment) + + name = textIfFind(member, 'name') + type = textIfFind(member, 'type') + sType = member.get('values') if member.get('values') is not None else sType + noautovalidity = boolGet(member, 'noautovalidity') + limittype = member.get('limittype') + + (externSync, externSyncPointer) = externSyncGet(member) + # No cases currently where a subtype of a struct is marked as externally synchronized. + assert externSyncPointer is None + + nullTerminated = False + length = member.get('altlen') if member.get('altlen') is not None else member.get('len') + if length: + # we will either find it like "null-terminated" or "enabledExtensionCount,null-terminated" + # This finds both + nullTerminated = 'null-terminated' in length + length = length.replace(',null-terminated', '') if 'null-terminated' in length else length + length = None if length == 'null-terminated' else length + + cdecl = self.makeCParamDecl(member, 0) + fullType = ' '.join(cdecl[:cdecl.rfind(name)].split()) + pointer = '*' in cdecl or type.startswith('PFN_') + const = 'const' in cdecl + # Some structs like VkTransformMatrixKHR have a 2D array + fixedSizeArray = [x[:-1] for x in cdecl.split('[') if x.endswith(']')] + + if fixedSizeArray and not length: + length = ','.join(fixedSizeArray) + + # Handle C bit field members + bitFieldWidth = int(cdecl.split(':')[1]) if ':' in cdecl else None + + # if a pointer, this can be a something like: + # optional="true,false" for ppGeometries + # optional="false,true" for pPhysicalDeviceCount + # the first is if the variable itself is optional + # the second is the value of the pointer is optional; + optionalValues = splitIfGet(member, 'optional') + optional = len(optionalValues) > 0 and optionalValues[0].lower() == "true" + optionalPointer = len(optionalValues) > 1 and optionalValues[1].lower() == "true" + + members.append(Member(name, type, fullType, noautovalidity, limittype, + const, length, nullTerminated, pointer, fixedSizeArray, + optional, optionalPointer, + externSync, cdecl, bitFieldWidth)) + + self.vk.structs[typeName] = Struct(typeName, [], extension, self.currentVersion, protect, members, + union, returnedOnly, sType, allowDuplicate, extends, extendedBy) + + elif category == 'handle': + if alias is not None: + self.handleAliasMap[typeName] = alias + return + type = typeElem.get('objtypeenum') + + # will resolve these later, the VulkanObjectType does not list things in dependent order + parent = typeElem.get('parent') + instance = typeName == 'VkInstance' + device = typeName == 'VkDevice' + + dispatchable = typeElem.find('type').text == 'VK_DEFINE_HANDLE' + + self.vk.handles[typeName] = Handle(typeName, [], type, protect, parent, instance, device, dispatchable, extension) + + elif category == 'define': + if typeName == 'VK_HEADER_VERSION': + self.vk.headerVersion = typeElem.find('name').tail.strip() + + elif category == 'bitmask': + if alias is not None: + self.flagsAliasMap[typeName] = alias + return + + # Bitmask types, i.e. flags + baseFlagsType = typeElem.find('type').text + bitWidth = 64 if baseFlagsType == 'VkFlags64' else 32 + + # Bitmask enum type is either in the 'requires' or 'bitvalues' attribute + # (for some reason there are two conventions) + bitmaskName = typeElem.get('bitvalues') + if bitmaskName is None: + bitmaskName = typeElem.get('requires') + + self.vk.flags[typeName] = Flags(typeName, [], bitmaskName, protect, baseFlagsType, bitWidth, True, extension) + + elif category == 'funcpointer': + requires = typeElem.get('requires') + protoElem = typeElem.find('proto') + returnType = textIfFind(protoElem, 'type') + + params = [] + for param in typeElem.findall('param'): + paramName = param.find('name').text + paramType = textIfFind(param, 'type') + + cdecl = self.makeCParamDecl(param, 0) + paramFullType = ' '.join(cdecl.split()[:-1]) + + params.append(FuncPointerParam(paramName, paramType, paramFullType, cdecl)) + + self.vk.funcPointers[typeName] = FuncPointer( + typeName, protect, returnType, requires, params, self.makeCParamDecl(typeElem, 0)) + + else: + # not all categories are used + # 'include' are only for headers + # 'group'/'enum' are routed to genGroup instead + return + + def genSpirv(self, spirvinfo, spirvName, alias): + OutputGenerator.genSpirv(self, spirvinfo, spirvName, alias) + spirvElem = spirvinfo.elem + name = spirvElem.get('name') + extension = True if spirvElem.tag == 'spirvextension' else False + capability = not extension + + enables = [] + for elem in spirvElem: + version = elem.attrib.get('version') + extensionEnable = elem.attrib.get('extension') + struct = elem.attrib.get('struct') + feature = elem.attrib.get('feature') + requires = elem.attrib.get('requires') + propertyEnable = elem.attrib.get('property') + member = elem.attrib.get('member') + value = elem.attrib.get('value') + enables.append(SpirvEnables(version, extensionEnable, struct, feature, + requires, propertyEnable, member, value)) + + self.vk.spirv.append(Spirv(name, extension, capability, enables)) + + def genFormat(self, format, formatinfo, alias): + OutputGenerator.genFormat(self, format, formatinfo, alias) + formatElem = format.elem + name = formatElem.get('name') + + components = [] + for component in formatElem.iterfind('component'): + type = component.get('name') + bits = component.get('bits') + numericFormat = component.get('numericFormat') + planeIndex = intIfGet(component, 'planeIndex') + components.append(FormatComponent(type, bits, numericFormat, planeIndex)) + + planes = [] + for plane in formatElem.iterfind('plane'): + index = int(plane.get('index')) + widthDivisor = int(plane.get('widthDivisor')) + heightDivisor = int(plane.get('heightDivisor')) + compatible = plane.get('compatible') + planes.append(FormatPlane(index, widthDivisor, heightDivisor, compatible)) + + className = formatElem.get('class') + blockSize = int(formatElem.get('blockSize')) + texelsPerBlock = int(formatElem.get('texelsPerBlock')) + blockExtent = splitIfGet(formatElem, 'blockExtent') + packed = intIfGet(formatElem, 'packed') + chroma = formatElem.get('chroma') + compressed = formatElem.get('compressed') + spirvImageFormat = formatElem.find('spirvimageformat') + if spirvImageFormat is not None: + spirvImageFormat = spirvImageFormat.get('name') + + self.vk.formats[name] = Format(name, className, blockSize, texelsPerBlock, + blockExtent, packed, chroma, compressed, + components, planes, spirvImageFormat) + + def genSyncStage(self, sync): + OutputGenerator.genSyncStage(self, sync) + syncElem = sync.elem + + support = maxSyncSupport + supportElem = syncElem.find('syncsupport') + if supportElem is not None: + queues = getQueues(supportElem) + stageNames = splitIfGet(supportElem, 'stage') + stages = [x for x in self.vk.bitmasks['VkPipelineStageFlagBits2'].flags if x.name in stageNames] if len(stageNames) > 0 else None + support = SyncSupport(queues, stages, False) + + equivalent = maxSyncEquivalent + equivalentElem = syncElem.find('syncequivalent') + if equivalentElem is not None: + stageNames = splitIfGet(equivalentElem, 'stage') + stages = [x for x in self.vk.bitmasks['VkPipelineStageFlagBits2'].flags if x.name in stageNames] if len(stageNames) > 0 else None + accessNames = splitIfGet(equivalentElem, 'access') + accesses = [x for x in self.vk.bitmasks['VkAccessFlagBits2'].flags if x.name in accessNames] if len(accessNames) > 0 else None + equivalent = SyncEquivalent(stages, accesses, False) + + flagName = syncElem.get('name') + flag = [x for x in self.vk.bitmasks['VkPipelineStageFlagBits2'].flags if x.name == flagName] + # This check is needed because not all API variants have VK_KHR_synchronization2 + if flag: + self.vk.syncStage.append(SyncStage(flag[0], support, equivalent)) + + def genSyncAccess(self, sync): + OutputGenerator.genSyncAccess(self, sync) + syncElem = sync.elem + + support = maxSyncSupport + supportElem = syncElem.find('syncsupport') + if supportElem is not None: + queues = getQueues(supportElem) + stageNames = splitIfGet(supportElem, 'stage') + stages = [x for x in self.vk.bitmasks['VkPipelineStageFlagBits2'].flags if x.name in stageNames] if len(stageNames) > 0 else None + support = SyncSupport(queues, stages, False) + + equivalent = maxSyncEquivalent + equivalentElem = syncElem.find('syncequivalent') + if equivalentElem is not None: + stageNames = splitIfGet(equivalentElem, 'stage') + stages = [x for x in self.vk.bitmasks['VkPipelineStageFlagBits2'].flags if x.name in stageNames] if len(stageNames) > 0 else None + accessNames = splitIfGet(equivalentElem, 'access') + accesses = [x for x in self.vk.bitmasks['VkAccessFlagBits2'].flags if x.name in accessNames] if len(accessNames) > 0 else None + equivalent = SyncEquivalent(stages, accesses, False) + + flagName = syncElem.get('name') + flag = [x for x in self.vk.bitmasks['VkAccessFlagBits2'].flags if x.name == flagName] + # This check is needed because not all API variants have VK_KHR_synchronization2 + if flag: + self.vk.syncAccess.append(SyncAccess(flag[0], support, equivalent)) + + def genSyncPipeline(self, sync): + OutputGenerator.genSyncPipeline(self, sync) + syncElem = sync.elem + name = syncElem.get('name') + depends = splitIfGet(syncElem, 'depends') + stages = [] + for stageElem in syncElem.findall('syncpipelinestage'): + order = stageElem.get('order') + before = stageElem.get('before') + after = stageElem.get('after') + value = stageElem.text + stages.append(SyncPipelineStage(order, before, after, value)) + + self.vk.syncPipeline.append(SyncPipeline(name, depends, stages)) + +# +# This object handles all the parsing from the video.xml (i.e. Video Std header definitions) +# It will fill in video standard definitions into the VulkanObject +class _VideoStdGenerator(BaseGenerator): + def __init__(self): + BaseGenerator.__init__(self) + self.vk.videoStd = VideoStd() + + # Track the current Video Std header we are processing + self.currentVideoStdHeader = None + + def write(self, data): + # We do not write anything here + return + + def beginFile(self, genOpts): + # We intentionally skip default BaseGenerator behavior + OutputGenerator.beginFile(self, genOpts) + + def endFile(self): + # Move parsed definitions to the Video Std definitions + self.vk.videoStd.enums = self.vk.enums + self.vk.videoStd.structs = self.vk.structs + self.vk.videoStd.constants = self.vk.constants + + # We intentionally skip default BaseGenerator behavior + OutputGenerator.endFile(self) + + def beginFeature(self, interface, emit): + # We intentionally skip default BaseGenerator behavior + OutputGenerator.beginFeature(self, interface, emit) + + # Only "extension" is possible in the video.xml, identifying the Video Std header + assert interface.tag == 'extension' + name = interface.get('name') + version: (str | None) = None + depends: list[str] = [] + + # Handle Video Std header version constant + for enum in interface.findall('require/enum[@value]'): + enumName = enum.get('name') + if enumName.endswith('_SPEC_VERSION'): + version = enum.get('value') + + # Handle dependencies on other Video Std headers + for type in interface.findall('require/type[@name]'): + typeName = type.get('name') + if typeName.startswith('vk_video/'): + depends.append(typeName[len('vk_video/'):-len('.h')]) + + headerFile = f'vk_video/{name}.h' + + self.vk.videoStd.headers[name] = VideoStdHeader(name, version, headerFile, depends) + + self.currentVideoStdHeader = self.vk.videoStd.headers[name] + + # Handle constants here as that seems the most straightforward + constantNames = [] + for enum in interface.findall('require/enum[@type]'): + constantNames.append(enum.get('name')) + self.addConstants(constantNames) + for constantName in constantNames: + self.vk.constants[constantName].videoStdHeader = self.currentVideoStdHeader.name + + def endFeature(self): + self.currentVideoStdHeader = None + + # We intentionally skip default BaseGenerator behavior + OutputGenerator.endFeature(self) + + def genCmd(self, cmdinfo, name, alias): + # video.xml should not contain any commands + assert False + + def genGroup(self, groupinfo, groupName, alias): + BaseGenerator.genGroup(self, groupinfo, groupName, alias) + + # We are supposed to be inside a video std header + assert self.currentVideoStdHeader is not None + + # Mark the enum with the Video Std header it comes from + if groupinfo.elem.get('type') == 'enum': + assert alias is None + self.vk.enums[groupName].videoStdHeader = self.currentVideoStdHeader.name + + def genType(self, typeInfo, typeName, alias): + BaseGenerator.genType(self, typeInfo, typeName, alias) + + # We are supposed to be inside a video std header + assert self.currentVideoStdHeader is not None + + # Mark the struct with the Video Std header it comes from + if typeInfo.elem.get('category') == 'struct': + assert alias is None + self.vk.structs[typeName].videoStdHeader = self.currentVideoStdHeader.name + + def genSpirv(self, spirvinfo, spirvName, alias): + # video.xml should not contain any SPIR-V info + assert False + + def genFormat(self, format, formatinfo, alias): + # video.xml should not contain any format info + assert False + + def genSyncStage(self, sync): + # video.xml should not contain any sync stage info + assert False + + def genSyncAccess(self, sync): + # video.xml should not contain any sync access info + assert False + + def genSyncPipeline(self, sync): + # video.xml should not contain any sync pipeline info + assert False diff --git a/scripts/generate_source.py b/scripts/generate_source.py index 835575a8fd..86c291b50b 100755 --- a/scripts/generate_source.py +++ b/scripts/generate_source.py @@ -47,7 +47,7 @@ def RunGenerators(api: str, registry: str, video_registry: str, directory: str, scripts = os.path.dirname(registry) scripts_directory_path = os.path.dirname(os.path.abspath(__file__)) registry_headers_path = os.path.join(scripts_directory_path, scripts) - sys.path.insert(0, registry_headers_path) + sys.path.append(registry_headers_path) try: from reg import Registry except: diff --git a/scripts/vulkan_object.py b/scripts/vulkan_object.py new file mode 100644 index 0000000000..7036e61e08 --- /dev/null +++ b/scripts/vulkan_object.py @@ -0,0 +1,627 @@ +#!/usr/bin/env python3 -i +# +# Copyright 2023-2025 The Khronos Group Inc. +# +# SPDX-License-Identifier: Apache-2.0 + +from dataclasses import dataclass, field +from enum import IntFlag, Enum, auto + +@dataclass +class FeatureRequirement: + """Each instance of FeatureRequirement is one part of the AND operation, + unless the struct/field are the same, then the depends are AND togethered""" + struct: str + field: str # Can have comma delimiter, which are expressed as OR + depends: (str | None) # ex) "VK_EXT_descriptor_indexing", "VK_VERSION_1_2+VkPhysicalDeviceVulkan12Features::descriptorIndexing" + +@dataclass +class Extension: + """""" + name: str # ex) VK_KHR_SURFACE + nameString: str # marco with string, ex) VK_KHR_SURFACE_EXTENSION_NAME + specVersion: str # marco with string, ex) VK_KHR_SURFACE_SPEC_VERSION + + # Only one will be True, the other is False + instance: bool + device: bool + + depends: (str | None) + vendorTag: (str | None) # ex) EXT, KHR, etc + platform: (str | None) # ex) android + protect: (str | None) # ex) VK_USE_PLATFORM_ANDROID_KHR + provisional: bool + promotedTo: (str | None) # ex) VK_VERSION_1_1 + deprecatedBy: (str | None) + obsoletedBy: (str | None) + specialUse: list[str] + featureRequirement: list[FeatureRequirement] + ratified: bool + + # These are here to allow for easy reverse lookups + # To prevent infinite recursion, other classes reference a string back to the Extension class + # Quotes allow us to forward declare the dataclass + handles: list['Handle'] = field(default_factory=list, init=False) + commands: list['Command'] = field(default_factory=list, init=False) + enums: list['Enum'] = field(default_factory=list, init=False) + bitmasks: list['Bitmask'] = field(default_factory=list, init=False) + flags: dict[str, list['Flags']] = field(default_factory=dict, init=False) + # Use the Enum name to see what fields are extended + enumFields: dict[str, list['EnumField']] = field(default_factory=dict, init=False) + # Use the Bitmask name to see what flag bits are added to it + flagBits: dict[str, list['Flag']] = field(default_factory=dict, init=False) + +@dataclass +class Version: + """ + which represents a version + This will NEVER be Version 1.0, since having 'no version' is same as being 1.0 + """ + name: str # ex) VK_VERSION_1_1 + nameString: str # ex) "VK_VERSION_1_1" (no marco, so has quotes) + nameApi: str # ex) VK_API_VERSION_1_1 + + featureRequirement: list[FeatureRequirement] + +@dataclass +class Deprecate: + """""" + link: (str | None) # Spec URL Anchor - ex) deprecation-dynamicrendering + version: (Version | None) + extensions: list[str] + +@dataclass +class Handle: + """ which represents a dispatch handle""" + name: str # ex) VkBuffer + aliases: list[str] # ex) ['VkSamplerYcbcrConversionKHR'] + + type: str # ex) VK_OBJECT_TYPE_BUFFER + protect: (str | None) # ex) VK_USE_PLATFORM_ANDROID_KHR + + parent: 'Handle' # Chain of parent handles, can be None + + # Only one will be True, the other is False + instance: bool + device: bool + + dispatchable: bool + + extensions: list[str] # All extensions that enable the handle + + def __lt__(self, other): + return self.name < other.name + + +@dataclass +class FuncPointerParam: + """""" + name: str + + # the "base type" - will not preserve the 'const' or pointer info + # ex) void, uint32_t, VkFormat, VkBuffer, etc + type: str + # the "full type" - will be cDeclaration without the type name + # ex) const void*, uint32_t, const VkFormat, VkBuffer*, etc + fullType: str + + # C string of param, ex) void* pUserData + cDeclaration: str + + +@dataclass +class FuncPointer: + """""" + name: str # ex) PFN_vkAllocationFunction + + protect: (str | None) # ex) 'VK_ENABLE_BETA_EXTENSIONS' + + returnType: str # ex) void, VkResult, etc + + requires: (str | None) # ex VkDebugUtilsMessengerCallbackDataEXT + + params: list[FuncPointerParam] # Each parameter of the command + + # function pointer typedef - ex: + # typedef void* (VKAPI_PTR void*PFN_vkAllocationFunction)(void* pUserData, size_t size, size_t alignment, VkSystemAllocationScope allocationScope); + cFunctionPointer: str + +class ExternSync(Enum): + NONE = auto() # no externsync attribute + ALWAYS = auto() # externsync="true" + MAYBE = auto() # externsync="maybe" + SUBTYPE = auto() # externsync="param->member" + SUBTYPE_MAYBE = auto() # externsync="maybe:param->member" + +@dataclass +class Param: + """""" + name: str # ex) pCreateInfo, pAllocator, pBuffer + alias: str + + # the "base type" - will not preserve the 'const' or pointer info + # ex) void, uint32_t, VkFormat, VkBuffer, etc + type: str + # the "full type" - will be cDeclaration without the type name + # ex) const void*, uint32_t, const VkFormat, VkBuffer*, etc + # For arrays, this will only display the type, fixedSizeArray can be used to get the length + fullType: str + + noAutoValidity: bool + + const: bool # type contains 'const' + length: (str | None) # the known length of pointer, will never be 'null-terminated' + nullTerminated: bool # If a UTF-8 string, it will be null-terminated + pointer: bool # type contains a pointer (include 'PFN' function pointers) + # Used to list how large an array of the type is + # ex) lineWidthRange is ['2'] + # ex) memoryTypes is ['VK_MAX_MEMORY_TYPES'] + # ex) VkTransformMatrixKHR:matrix is ['3', '4'] + fixedSizeArray: list[str] + + optional: bool + optionalPointer: bool # if type contains a pointer, is the pointer value optional + + externSync: ExternSync + externSyncPointer: (str | None) # if type contains a pointer (externSync is SUBTYPE*), + # only a specific member is externally synchronized. + + # C string of member, example: + # - const void* pNext + # - VkFormat format + # - VkStructureType sType + cDeclaration: str + + def __lt__(self, other): + return self.name < other.name + +class Queues(IntFlag): + TRANSFER = auto() # VK_QUEUE_TRANSFER_BIT + GRAPHICS = auto() # VK_QUEUE_GRAPHICS_BIT + COMPUTE = auto() # VK_QUEUE_COMPUTE_BIT + PROTECTED = auto() # VK_QUEUE_PROTECTED_BIT + SPARSE_BINDING = auto() # VK_QUEUE_SPARSE_BINDING_BIT + OPTICAL_FLOW = auto() # VK_QUEUE_OPTICAL_FLOW_BIT_NV + DECODE = auto() # VK_QUEUE_VIDEO_DECODE_BIT_KHR + ENCODE = auto() # VK_QUEUE_VIDEO_ENCODE_BIT_KHR + DATA_GRAPH = auto() # VK_QUEUE_DATA_GRAPH_BIT_ARM + +class CommandScope(Enum): + NONE = auto() + INSIDE = auto() + OUTSIDE = auto() + BOTH = auto() + +@dataclass +class Command: + """""" + name: str # ex) vkCmdDraw + alias: (str | None) # Because commands are interfaces into layers/drivers, we need all command alias + protect: (str | None) # ex) 'VK_ENABLE_BETA_EXTENSIONS' + + extensions: list[str] # All extensions that enable the struct + version: (Version | None) # None if Version 1.0 + + returnType: str # ex) void, VkResult, etc + + params: list[Param] # Each parameter of the command + + # Only one will be True, the other is False + instance: bool + device: bool + + tasks: list[str] # ex) [ action, state, synchronization ] + queues: Queues # zero == No Queues found (represents restriction which queue type can be used) + allowNoQueues: bool # VK_KHR_maintenance9 allows some calls to be done with zero queues + successCodes: list[str] # ex) [ VK_SUCCESS, VK_INCOMPLETE ] + errorCodes: list[str] # ex) [ VK_ERROR_OUT_OF_HOST_MEMORY ] + + # Shows support if command can be in a primary and/or secondary command buffer + primary: bool + secondary: bool + + renderPass: CommandScope + videoCoding: CommandScope + + implicitExternSyncParams: list[str] + + deprecate: (Deprecate | None) + + # C prototype string - ex: + # VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance( + # const VkInstanceCreateInfo* pCreateInfo, + # const VkAllocationCallbacks* pAllocator, + # VkInstance* pInstance); + cPrototype: str + + # function pointer typedef - ex: + # typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance) + # (const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance); + cFunctionPointer: str + + def __lt__(self, other): + return self.name < other.name + +@dataclass +class Member: + """""" + name: str # ex) sType, pNext, flags, size, usage + + # the "base type" - will not preserve the 'const' or pointer info + # ex) void, uint32_t, VkFormat, VkBuffer, etc + type: str + # the "full type" - will be cDeclaration without the type name + # ex) const void*, uint32_t, const VkFormat, VkBuffer*, etc + # For arrays, this will only display the type, fixedSizeArray can be used to get the length + fullType: str + + noAutoValidity: bool + limitType: (str | None) # ex) 'max', 'bitmask', 'bits', 'min,mul' + + const: bool # type contains 'const' + length: (str | None) # the known length of pointer, will never be 'null-terminated' + nullTerminated: bool # If a UTF-8 string, it will be null-terminated + pointer: bool # type contains a pointer (include 'PFN' function pointers) + # Used to list how large an array of the type is + # ex) lineWidthRange is ['2'] + # ex) memoryTypes is ['VK_MAX_MEMORY_TYPES'] + # ex) VkTransformMatrixKHR:matrix is ['3', '4'] + fixedSizeArray: list[str] + + optional: bool + optionalPointer: bool # if type contains a pointer, is the pointer value optional + + externSync: ExternSync + + # C string of member, example: + # - const void* pNext + # - VkFormat format + # - VkStructureType sType + cDeclaration: str + + bitFieldWidth: (int | None) # bit width (only for bit field struct members) + + def __lt__(self, other): + return self.name < other.name + +@dataclass +class Struct: + """ or """ + name: str # ex) VkImageSubresource2 + aliases: list[str] # ex) ['VkImageSubresource2KHR', 'VkImageSubresource2EXT'] + + extensions: list[str] # All extensions that enable the struct + version: (Version | None) # None if Version 1.0 + protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS + + members: list[Member] + + union: bool # Unions are just a subset of a Structs + returnedOnly: bool + + sType: (str | None) # ex) VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO + allowDuplicate: bool # can have a pNext point to itself + + # These use to be list['Struct'] but some circular loops occur and cause + # pydevd warnings and made debugging slow (30 seconds to index a Struct) + extends: list[str] # Struct names that this struct extends + extendedBy: list[str] # Struct names that can be extended by this struct + + # This field is only set for enum definitions coming from Video Std headers + videoStdHeader: (str | None) = None + + def __lt__(self, other): + return self.name < other.name + +@dataclass +class EnumField: + """ of type enum""" + name: str # ex) VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT + aliases: list[str] # ex) ['VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT'] + + protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS + + negative: bool # True if negative values are allowed (ex. VkResult) + value: int + valueStr: str # value as shown in spec (ex. "0", "2", "1000267000", "0x00000004") + + # some fields are enabled from 2 extensions (ex) VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR) + extensions: list[str] # None if part of 1.0 core + + def __lt__(self, other): + return self.name < other.name + +@dataclass +class Enum: + """ of type enum""" + name: str # ex) VkLineRasterizationMode + aliases: list[str] # ex) ['VkLineRasterizationModeKHR', 'VkLineRasterizationModeEXT'] + + protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS + + bitWidth: int # 32 or 64 (currently all are 32, but field is to match with Bitmask) + returnedOnly: bool + + fields: list[EnumField] + + extensions: list[str] # None if part of 1.0 core + # Unique list of all extension that are involved in 'fields' (superset of 'extensions') + fieldExtensions: list[str] + + # This field is only set for enum definitions coming from Video Std headers + videoStdHeader: (str | None) = None + + def __lt__(self, other): + return self.name < other.name + +@dataclass +class Flag: + """ of type bitmask""" + name: str # ex) VK_ACCESS_2_SHADER_READ_BIT + aliases: str # ex) ['VK_ACCESS_2_SHADER_READ_BIT_KHR'] + + protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS + + value: int + valueStr: str # value as shown in spec (ex. 0x00000000", "0x00000004", "0x0000000F", "0x800000000ULL") + multiBit: bool # if true, more than one bit is set (ex) VK_SHADER_STAGE_ALL_GRAPHICS) + zero: bool # if true, the value is zero (ex) VK_PIPELINE_STAGE_NONE) + + # some fields are enabled from 2 extensions (ex) VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT) + extensions: list[str] # None if part of 1.0 core + + def __lt__(self, other): + return self.name < other.name + +@dataclass +class Bitmask: + """ of type bitmask""" + name: str # ex) VkAccessFlagBits2 + aliases: list[str] # ex) ['VkAccessFlagBits2KHR'] + + flagName: str # ex) VkAccessFlags2 + protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS + + bitWidth: int # 32 or 64 + returnedOnly: bool + + flags: list[Flag] + + extensions: list[str] # None if part of 1.0 core + # Unique list of all extension that are involved in 'flag' (superset of 'extensions') + flagExtensions: list[str] + + def __lt__(self, other): + return self.name < other.name + +@dataclass +class Flags: + """ defining flags types""" + name: str # ex) VkAccessFlags2 + aliases: list[str] # ex) [`VkAccessFlags2KHR`] + + bitmaskName: (str | None) # ex) VkAccessFlagBits2 + protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS + + baseFlagsType: str # ex) VkFlags + bitWidth: int # 32 or 64 + returnedOnly: bool + + extensions: list[str] # None if part of 1.0 core + + def __lt__(self, other): + return self.name < other.name + +@dataclass +class Constant: + name: str # ex) VK_UUID_SIZE + type: str # ex) uint32_t, float + value: (int | float) + valueStr: str # value as shown in spec (ex. "(~0U)", "256U", etc) + + # This field is only set for enum definitions coming from Video Std headers + videoStdHeader: (str | None) = None + +@dataclass +class FormatComponent: + """""" + type: str # ex) R, G, B, A, D, S, etc + bits: str # will be an INT or 'compressed' + numericFormat: str # ex) UNORM, SINT, etc + planeIndex: (int | None) # None if no planeIndex in format + +@dataclass +class FormatPlane: + """""" + index: int + widthDivisor: int + heightDivisor: int + compatible: str + +@dataclass +class Format: + """""" + name: str + className: str + blockSize: int + texelsPerBlock: int + blockExtent: list[str] + packed: (int | None) # None == not-packed + chroma: (str | None) + compressed: (str | None) + components: list[FormatComponent] # + planes: list[FormatPlane] # + spirvImageFormat: (str | None) + +@dataclass +class SyncSupport: + """""" + queues: Queues + stages: list[Flag] # VkPipelineStageFlagBits2 + max: bool # If this supports max values + +@dataclass +class SyncEquivalent: + """""" + stages: list[Flag] # VkPipelineStageFlagBits2 + accesses: list[Flag] # VkAccessFlagBits2 + max: bool # If this equivalent to everything + +@dataclass +class SyncStage: + """""" + flag: Flag # VkPipelineStageFlagBits2 + support: SyncSupport + equivalent: SyncEquivalent + +@dataclass +class SyncAccess: + """""" + flag: Flag # VkAccessFlagBits2 + support: SyncSupport + equivalent: SyncEquivalent + +@dataclass +class SyncPipelineStage: + """""" + order: (str | None) + before: (str | None) + after: (str | None) + value: str + +@dataclass +class SyncPipeline: + """""" + name: str + depends: list[str] + stages: list[SyncPipelineStage] + +@dataclass +class SpirvEnables: + """What is needed to enable the SPIR-V element""" + version: (str | None) + extension: (str | None) + struct: (str | None) + feature: (str | None) + requires: (str | None) + property: (str | None) + member: (str | None) + value: (str | None) + +@dataclass +class Spirv: + """ and """ + name: str + # Only one will be True, the other is False + extension: bool + capability: bool + enable: list[SpirvEnables] + +@dataclass +class VideoRequiredCapabilities: + """""" + struct: str # ex) VkVideoEncodeCapabilitiesKHR + member: str # ex) flags + value: str # ex) VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR + # may contain XML boolean expressions ("+" means AND, "," means OR) + +@dataclass +class VideoFormat: + """""" + name: str # ex) Decode Output + usage: str # ex) VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR + # may contain XML boolean expressions ("+" means AND, "," means OR) + + requiredCaps: list[VideoRequiredCapabilities] + properties: dict[str, str] + + def __lt__(self, other): + return self.name < other.name + +@dataclass +class VideoProfileMember: + """ and """ + name: str + # Video profile struct member (value attribute of ) value as key, + # profile name substring (name attribute of ) as value + values: dict[str, str] + +@dataclass +class VideoProfiles: + """""" + name: str + members: dict[str, VideoProfileMember] + +@dataclass +class VideoCodec: + """""" + name: str # ex) H.264 Decode + value: (str | None) # If no video codec operation flag bit is associated with the codec + # then it is a codec category (e.g. decode, encode), not a specific codec + + profiles: dict[str, VideoProfiles] + capabilities: dict[str, str] + formats: dict[str, VideoFormat] + + def __lt__(self, other): + return self.name < other.name + +@dataclass +class VideoStdHeader: + """ in video.xml""" + name: str # ex) vulkan_video_codec_h264std_decode + version: (str | None) # ex) VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_API_VERSION_1_0_0 + # None if it is a shared common Video Std header + + headerFile: str # ex) vk_video/vulkan_video_codec_h264std_decode.h + + # Other Video Std headers that this one depends on + depends: list[str] + +@dataclass +class VideoStd: + headers: dict[str, VideoStdHeader] = field(default_factory=dict, init=False) + + enums: dict[str, Enum] = field(default_factory=dict, init=False) + structs: dict[str, Struct] = field(default_factory=dict, init=False) + constants: dict[str, Constant] = field(default_factory=dict, init=False) + +# This is the global Vulkan Object that holds all the information from parsing the XML +# This class is designed so all generator scripts can use this to obtain data +@dataclass +class VulkanObject(): + headerVersion: int = 0 # value of VK_HEADER_VERSION (ex. 345) + headerVersionComplete: str = '' # value of VK_HEADER_VERSION_COMPLETE (ex. '1.2.345' ) + + extensions: dict[str, Extension] = field(default_factory=dict, init=False) + versions: dict[str, Version] = field(default_factory=dict, init=False) + + handles: dict[str, Handle] = field(default_factory=dict, init=False) + commands: dict[str, Command] = field(default_factory=dict, init=False) + structs: dict[str, Struct] = field(default_factory=dict, init=False) + enums: dict[str, Enum] = field(default_factory=dict, init=False) + bitmasks: dict[str, Bitmask] = field(default_factory=dict, init=False) + flags: dict[str, Flags] = field(default_factory=dict, init=False) + constants: dict[str, Constant] = field(default_factory=dict, init=False) + formats: dict[str, Format] = field(default_factory=dict, init=False) + + funcPointers: dict[str, FuncPointer] = field(default_factory=dict, init=False) + + syncStage: list[SyncStage] = field(default_factory=list, init=False) + syncAccess: list[SyncAccess] = field(default_factory=list, init=False) + syncPipeline: list[SyncPipeline] = field(default_factory=list, init=False) + + spirv: list[Spirv] = field(default_factory=list, init=False) + + # ex) [ xlib : VK_USE_PLATFORM_XLIB_KHR ] + platforms: dict[str, str] = field(default_factory=dict, init=False) + # list of all vendor Suffix names (KHR, EXT, etc. ) + vendorTags: list[str] = field(default_factory=list, init=False) + # ex) [ Queues.COMPUTE : VK_QUEUE_COMPUTE_BIT ] + queueBits: dict[IntFlag, str] = field(default_factory=dict, init=False) + + # Video codec information from the vk.xml + videoCodecs: dict[str, VideoCodec] = field(default_factory=dict, init=False) + + # Video Std header information from the video.xml + videoStd: (VideoStd | None) = None From 7fd928aed14d3bd497d43ceb1b8310cb2a239b32 Mon Sep 17 00:00:00 2001 From: Emre Kultursay Date: Thu, 26 Feb 2026 09:43:56 -0800 Subject: [PATCH 02/14] Modify the api_dump layer to dump only API names --- layersvt/generated/api_dump_dispatch.h | 11114 +++-------------- layersvt/generated/api_dump_implementation.h | 24 - scripts/generators/api_dump_generator.py | 48 +- 3 files changed, 1553 insertions(+), 9633 deletions(-) diff --git a/layersvt/generated/api_dump_dispatch.h b/layersvt/generated/api_dump_dispatch.h index 72551aa286..60fd4f868d 100644 --- a/layersvt/generated/api_dump_dispatch.h +++ b/layersvt/generated/api_dump_dispatch.h @@ -28,32 +28,18 @@ template VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyInstance", "instance, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyInstance(ApiDumpInstance::current(), instance, pAllocator); - } + if (ApiDumpInstance::current().shouldDumpOutput()) { + ApiDumpInstance::current().settings().stream() << "vkDestroyInstance\n"; } auto dispatch_key = get_dispatch_key(instance); instance_dispatch_table(instance)->DestroyInstance(instance, pAllocator); destroy_instance_dispatch_table(dispatch_key); - if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyInstance(ApiDumpInstance::current(), instance, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); - } } template VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkEnumeratePhysicalDevices", "instance, pPhysicalDeviceCount, pPhysicalDevices", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkEnumeratePhysicalDevices(ApiDumpInstance::current(), instance, pPhysicalDeviceCount, pPhysicalDevices); - } + if (ApiDumpInstance::current().shouldDumpOutput()) { + ApiDumpInstance::current().settings().stream() << "vkEnumeratePhysicalDevices\n"; } VkResult result = instance_dispatch_table(instance)->EnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices); @@ -62,662 +48,297 @@ VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices(VkInstance instance, u ApiDumpInstance::current().set_vk_instance(pPhysicalDevices[i], instance); } } - if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkEnumeratePhysicalDevices(ApiDumpInstance::current(), instance, pPhysicalDeviceCount, pPhysicalDevices); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); - } return result; } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceFeatures", "physicalDevice, pFeatures", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceFeatures(ApiDumpInstance::current(), physicalDevice, pFeatures); - } - } - instance_dispatch_table(physicalDevice)->GetPhysicalDeviceFeatures(physicalDevice, pFeatures); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceFeatures(ApiDumpInstance::current(), physicalDevice, pFeatures); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceFeatures\n"; } + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceFeatures(physicalDevice, pFeatures); } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceFormatProperties", "physicalDevice, format, pFormatProperties", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceFormatProperties(ApiDumpInstance::current(), physicalDevice, format, pFormatProperties); - } - } - instance_dispatch_table(physicalDevice)->GetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceFormatProperties(ApiDumpInstance::current(), physicalDevice, format, pFormatProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceFormatProperties\n"; } + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceImageFormatProperties", "physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceImageFormatProperties(ApiDumpInstance::current(), physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceImageFormatProperties(ApiDumpInstance::current(), physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceImageFormatProperties\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties); return result; } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceProperties", "physicalDevice, pProperties", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceProperties(ApiDumpInstance::current(), physicalDevice, pProperties); - } - } - instance_dispatch_table(physicalDevice)->GetPhysicalDeviceProperties(physicalDevice, pProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceProperties(ApiDumpInstance::current(), physicalDevice, pProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceProperties\n"; } + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceProperties(physicalDevice, pProperties); } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceQueueFamilyProperties", "physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceQueueFamilyProperties(ApiDumpInstance::current(), physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); - } - } - instance_dispatch_table(physicalDevice)->GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceQueueFamilyProperties(ApiDumpInstance::current(), physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceQueueFamilyProperties\n"; } + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceMemoryProperties", "physicalDevice, pMemoryProperties", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceMemoryProperties(ApiDumpInstance::current(), physicalDevice, pMemoryProperties); - } - } - instance_dispatch_table(physicalDevice)->GetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceMemoryProperties(ApiDumpInstance::current(), physicalDevice, pMemoryProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceMemoryProperties\n"; } + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties); } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceSparseImageFormatProperties", "physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceSparseImageFormatProperties(ApiDumpInstance::current(), physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties); - } - } - instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceSparseImageFormatProperties(ApiDumpInstance::current(), physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceSparseImageFormatProperties\n"; } + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties); } template VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkEnumeratePhysicalDeviceGroups", "instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkEnumeratePhysicalDeviceGroups(ApiDumpInstance::current(), instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); - } - } - VkResult result = instance_dispatch_table(instance)->EnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkEnumeratePhysicalDeviceGroups(ApiDumpInstance::current(), instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkEnumeratePhysicalDeviceGroups\n"; } + VkResult result = instance_dispatch_table(instance)->EnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); return result; } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceFeatures2", "physicalDevice, pFeatures", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceFeatures2(ApiDumpInstance::current(), physicalDevice, pFeatures); - } - } - instance_dispatch_table(physicalDevice)->GetPhysicalDeviceFeatures2(physicalDevice, pFeatures); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceFeatures2(ApiDumpInstance::current(), physicalDevice, pFeatures); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceFeatures2\n"; } + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceFeatures2(physicalDevice, pFeatures); } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceProperties2", "physicalDevice, pProperties", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceProperties2(ApiDumpInstance::current(), physicalDevice, pProperties); - } - } - instance_dispatch_table(physicalDevice)->GetPhysicalDeviceProperties2(physicalDevice, pProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceProperties2(ApiDumpInstance::current(), physicalDevice, pProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceProperties2\n"; } + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceProperties2(physicalDevice, pProperties); } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceFormatProperties2", "physicalDevice, format, pFormatProperties", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceFormatProperties2(ApiDumpInstance::current(), physicalDevice, format, pFormatProperties); - } - } - instance_dispatch_table(physicalDevice)->GetPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceFormatProperties2(ApiDumpInstance::current(), physicalDevice, format, pFormatProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceFormatProperties2\n"; } + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceImageFormatProperties2", "physicalDevice, pImageFormatInfo, pImageFormatProperties", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceImageFormatProperties2(ApiDumpInstance::current(), physicalDevice, pImageFormatInfo, pImageFormatProperties); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceImageFormatProperties2(physicalDevice, pImageFormatInfo, pImageFormatProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceImageFormatProperties2(ApiDumpInstance::current(), physicalDevice, pImageFormatInfo, pImageFormatProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceImageFormatProperties2\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceImageFormatProperties2(physicalDevice, pImageFormatInfo, pImageFormatProperties); return result; } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceQueueFamilyProperties2", "physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceQueueFamilyProperties2(ApiDumpInstance::current(), physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); - } - } - instance_dispatch_table(physicalDevice)->GetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceQueueFamilyProperties2(ApiDumpInstance::current(), physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceQueueFamilyProperties2\n"; } + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceMemoryProperties2", "physicalDevice, pMemoryProperties", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceMemoryProperties2(ApiDumpInstance::current(), physicalDevice, pMemoryProperties); - } - } - instance_dispatch_table(physicalDevice)->GetPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceMemoryProperties2(ApiDumpInstance::current(), physicalDevice, pMemoryProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceMemoryProperties2\n"; } + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties); } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceSparseImageFormatProperties2", "physicalDevice, pFormatInfo, pPropertyCount, pProperties", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceSparseImageFormatProperties2(ApiDumpInstance::current(), physicalDevice, pFormatInfo, pPropertyCount, pProperties); - } - } - instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSparseImageFormatProperties2(physicalDevice, pFormatInfo, pPropertyCount, pProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceSparseImageFormatProperties2(ApiDumpInstance::current(), physicalDevice, pFormatInfo, pPropertyCount, pProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceSparseImageFormatProperties2\n"; } + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSparseImageFormatProperties2(physicalDevice, pFormatInfo, pPropertyCount, pProperties); } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceExternalBufferProperties", "physicalDevice, pExternalBufferInfo, pExternalBufferProperties", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceExternalBufferProperties(ApiDumpInstance::current(), physicalDevice, pExternalBufferInfo, pExternalBufferProperties); - } - } - instance_dispatch_table(physicalDevice)->GetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceExternalBufferProperties(ApiDumpInstance::current(), physicalDevice, pExternalBufferInfo, pExternalBufferProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceExternalBufferProperties\n"; } + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties); } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceExternalFenceProperties", "physicalDevice, pExternalFenceInfo, pExternalFenceProperties", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceExternalFenceProperties(ApiDumpInstance::current(), physicalDevice, pExternalFenceInfo, pExternalFenceProperties); - } - } - instance_dispatch_table(physicalDevice)->GetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceExternalFenceProperties(ApiDumpInstance::current(), physicalDevice, pExternalFenceInfo, pExternalFenceProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceExternalFenceProperties\n"; } + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties); } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceExternalSemaphoreProperties", "physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceExternalSemaphoreProperties(ApiDumpInstance::current(), physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); - } - } - instance_dispatch_table(physicalDevice)->GetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceExternalSemaphoreProperties(ApiDumpInstance::current(), physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceExternalSemaphoreProperties\n"; } + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceToolProperties", "physicalDevice, pToolCount, pToolProperties", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceToolProperties(ApiDumpInstance::current(), physicalDevice, pToolCount, pToolProperties); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceToolProperties(physicalDevice, pToolCount, pToolProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceToolProperties(ApiDumpInstance::current(), physicalDevice, pToolCount, pToolProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceToolProperties\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceToolProperties(physicalDevice, pToolCount, pToolProperties); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroySurfaceKHR", "instance, surface, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroySurfaceKHR(ApiDumpInstance::current(), instance, surface, pAllocator); - } - } - instance_dispatch_table(instance)->DestroySurfaceKHR(instance, surface, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroySurfaceKHR(ApiDumpInstance::current(), instance, surface, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroySurfaceKHR\n"; } + instance_dispatch_table(instance)->DestroySurfaceKHR(instance, surface, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceSurfaceSupportKHR", "physicalDevice, queueFamilyIndex, surface, pSupported", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceSurfaceSupportKHR(ApiDumpInstance::current(), physicalDevice, queueFamilyIndex, surface, pSupported); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceSurfaceSupportKHR(ApiDumpInstance::current(), physicalDevice, queueFamilyIndex, surface, pSupported); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceSurfaceSupportKHR\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceSurfaceCapabilitiesKHR", "physicalDevice, surface, pSurfaceCapabilities", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(ApiDumpInstance::current(), physicalDevice, surface, pSurfaceCapabilities); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(ApiDumpInstance::current(), physicalDevice, surface, pSurfaceCapabilities); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceSurfaceCapabilitiesKHR\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceSurfaceFormatsKHR", "physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceSurfaceFormatsKHR(ApiDumpInstance::current(), physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceSurfaceFormatsKHR(ApiDumpInstance::current(), physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceSurfaceFormatsKHR\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceSurfacePresentModesKHR", "physicalDevice, surface, pPresentModeCount, pPresentModes", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceSurfacePresentModesKHR(ApiDumpInstance::current(), physicalDevice, surface, pPresentModeCount, pPresentModes); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceSurfacePresentModesKHR(ApiDumpInstance::current(), physicalDevice, surface, pPresentModeCount, pPresentModes); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceSurfacePresentModesKHR\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDevicePresentRectanglesKHR", "physicalDevice, surface, pRectCount, pRects", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDevicePresentRectanglesKHR(ApiDumpInstance::current(), physicalDevice, surface, pRectCount, pRects); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDevicePresentRectanglesKHR(ApiDumpInstance::current(), physicalDevice, surface, pRectCount, pRects); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDevicePresentRectanglesKHR\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceDisplayPropertiesKHR", "physicalDevice, pPropertyCount, pProperties", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceDisplayPropertiesKHR(ApiDumpInstance::current(), physicalDevice, pPropertyCount, pProperties); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, pPropertyCount, pProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceDisplayPropertiesKHR(ApiDumpInstance::current(), physicalDevice, pPropertyCount, pProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceDisplayPropertiesKHR\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, pPropertyCount, pProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceDisplayPlanePropertiesKHR", "physicalDevice, pPropertyCount, pProperties", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(ApiDumpInstance::current(), physicalDevice, pPropertyCount, pProperties); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, pPropertyCount, pProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(ApiDumpInstance::current(), physicalDevice, pPropertyCount, pProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceDisplayPlanePropertiesKHR\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, pPropertyCount, pProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDisplayPlaneSupportedDisplaysKHR", "physicalDevice, planeIndex, pDisplayCount, pDisplays", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDisplayPlaneSupportedDisplaysKHR(ApiDumpInstance::current(), physicalDevice, planeIndex, pDisplayCount, pDisplays); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->GetDisplayPlaneSupportedDisplaysKHR(physicalDevice, planeIndex, pDisplayCount, pDisplays); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDisplayPlaneSupportedDisplaysKHR(ApiDumpInstance::current(), physicalDevice, planeIndex, pDisplayCount, pDisplays); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDisplayPlaneSupportedDisplaysKHR\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->GetDisplayPlaneSupportedDisplaysKHR(physicalDevice, planeIndex, pDisplayCount, pDisplays); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDisplayModePropertiesKHR", "physicalDevice, display, pPropertyCount, pProperties", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDisplayModePropertiesKHR(ApiDumpInstance::current(), physicalDevice, display, pPropertyCount, pProperties); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->GetDisplayModePropertiesKHR(physicalDevice, display, pPropertyCount, pProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDisplayModePropertiesKHR(ApiDumpInstance::current(), physicalDevice, display, pPropertyCount, pProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDisplayModePropertiesKHR\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->GetDisplayModePropertiesKHR(physicalDevice, display, pPropertyCount, pProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateDisplayModeKHR", "physicalDevice, display, pCreateInfo, pAllocator, pMode", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateDisplayModeKHR(ApiDumpInstance::current(), physicalDevice, display, pCreateInfo, pAllocator, pMode); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->CreateDisplayModeKHR(physicalDevice, display, pCreateInfo, pAllocator, pMode); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateDisplayModeKHR(ApiDumpInstance::current(), physicalDevice, display, pCreateInfo, pAllocator, pMode); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateDisplayModeKHR\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->CreateDisplayModeKHR(physicalDevice, display, pCreateInfo, pAllocator, pMode); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDisplayPlaneCapabilitiesKHR", "physicalDevice, mode, planeIndex, pCapabilities", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDisplayPlaneCapabilitiesKHR(ApiDumpInstance::current(), physicalDevice, mode, planeIndex, pCapabilities); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->GetDisplayPlaneCapabilitiesKHR(physicalDevice, mode, planeIndex, pCapabilities); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDisplayPlaneCapabilitiesKHR(ApiDumpInstance::current(), physicalDevice, mode, planeIndex, pCapabilities); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDisplayPlaneCapabilitiesKHR\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->GetDisplayPlaneCapabilitiesKHR(physicalDevice, mode, planeIndex, pCapabilities); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateDisplayPlaneSurfaceKHR", "instance, pCreateInfo, pAllocator, pSurface", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateDisplayPlaneSurfaceKHR(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface); - } - } - VkResult result = instance_dispatch_table(instance)->CreateDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateDisplayPlaneSurfaceKHR(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateDisplayPlaneSurfaceKHR\n"; } + VkResult result = instance_dispatch_table(instance)->CreateDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); return result; } #if defined(VK_USE_PLATFORM_XLIB_KHR) template VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateXlibSurfaceKHR", "instance, pCreateInfo, pAllocator, pSurface", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateXlibSurfaceKHR(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface); - } - } - VkResult result = instance_dispatch_table(instance)->CreateXlibSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateXlibSurfaceKHR(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateXlibSurfaceKHR\n"; } + VkResult result = instance_dispatch_table(instance)->CreateXlibSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); return result; } template VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceXlibPresentationSupportKHR", "physicalDevice, queueFamilyIndex, dpy, visualID", "VkBool32"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceXlibPresentationSupportKHR(ApiDumpInstance::current(), physicalDevice, queueFamilyIndex, dpy, visualID); - } - } - VkBool32 result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceXlibPresentationSupportKHR(physicalDevice, queueFamilyIndex, dpy, visualID); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkBool32", result); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceXlibPresentationSupportKHR(ApiDumpInstance::current(), physicalDevice, queueFamilyIndex, dpy, visualID); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceXlibPresentationSupportKHR\n"; } + VkBool32 result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceXlibPresentationSupportKHR(physicalDevice, queueFamilyIndex, dpy, visualID); return result; } #endif // VK_USE_PLATFORM_XLIB_KHR @@ -725,41 +346,19 @@ VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR(VkP template VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateXcbSurfaceKHR", "instance, pCreateInfo, pAllocator, pSurface", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateXcbSurfaceKHR(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface); - } - } - VkResult result = instance_dispatch_table(instance)->CreateXcbSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateXcbSurfaceKHR(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateXcbSurfaceKHR\n"; } + VkResult result = instance_dispatch_table(instance)->CreateXcbSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); return result; } template VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceXcbPresentationSupportKHR", "physicalDevice, queueFamilyIndex, connection, visual_id", "VkBool32"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceXcbPresentationSupportKHR(ApiDumpInstance::current(), physicalDevice, queueFamilyIndex, connection, visual_id); - } - } - VkBool32 result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceXcbPresentationSupportKHR(physicalDevice, queueFamilyIndex, connection, visual_id); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkBool32", result); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceXcbPresentationSupportKHR(ApiDumpInstance::current(), physicalDevice, queueFamilyIndex, connection, visual_id); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceXcbPresentationSupportKHR\n"; } + VkBool32 result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceXcbPresentationSupportKHR(physicalDevice, queueFamilyIndex, connection, visual_id); return result; } #endif // VK_USE_PLATFORM_XCB_KHR @@ -767,41 +366,19 @@ VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR(VkPh template VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateWaylandSurfaceKHR", "instance, pCreateInfo, pAllocator, pSurface", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateWaylandSurfaceKHR(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface); - } - } - VkResult result = instance_dispatch_table(instance)->CreateWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateWaylandSurfaceKHR(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateWaylandSurfaceKHR\n"; } + VkResult result = instance_dispatch_table(instance)->CreateWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); return result; } template VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceWaylandPresentationSupportKHR", "physicalDevice, queueFamilyIndex, display", "VkBool32"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceWaylandPresentationSupportKHR(ApiDumpInstance::current(), physicalDevice, queueFamilyIndex, display); - } - } - VkBool32 result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceWaylandPresentationSupportKHR(physicalDevice, queueFamilyIndex, display); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkBool32", result); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceWaylandPresentationSupportKHR(ApiDumpInstance::current(), physicalDevice, queueFamilyIndex, display); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceWaylandPresentationSupportKHR\n"; } + VkBool32 result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceWaylandPresentationSupportKHR(physicalDevice, queueFamilyIndex, display); return result; } #endif // VK_USE_PLATFORM_WAYLAND_KHR @@ -809,21 +386,10 @@ VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR( template VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateAndroidSurfaceKHR", "instance, pCreateInfo, pAllocator, pSurface", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateAndroidSurfaceKHR(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface); - } - } - VkResult result = instance_dispatch_table(instance)->CreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateAndroidSurfaceKHR(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateAndroidSurfaceKHR\n"; } + VkResult result = instance_dispatch_table(instance)->CreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); return result; } #endif // VK_USE_PLATFORM_ANDROID_KHR @@ -831,745 +397,339 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR(VkInstance instance, co template VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateWin32SurfaceKHR", "instance, pCreateInfo, pAllocator, pSurface", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateWin32SurfaceKHR(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface); - } - } - VkResult result = instance_dispatch_table(instance)->CreateWin32SurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateWin32SurfaceKHR(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateWin32SurfaceKHR\n"; } + VkResult result = instance_dispatch_table(instance)->CreateWin32SurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); return result; } template VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceWin32PresentationSupportKHR", "physicalDevice, queueFamilyIndex", "VkBool32"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceWin32PresentationSupportKHR(ApiDumpInstance::current(), physicalDevice, queueFamilyIndex); - } - } - VkBool32 result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice, queueFamilyIndex); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkBool32", result); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceWin32PresentationSupportKHR(ApiDumpInstance::current(), physicalDevice, queueFamilyIndex); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceWin32PresentationSupportKHR\n"; } + VkBool32 result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice, queueFamilyIndex); return result; } #endif // VK_USE_PLATFORM_WIN32_KHR template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoCapabilitiesKHR(VkPhysicalDevice physicalDevice, const VkVideoProfileInfoKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceVideoCapabilitiesKHR", "physicalDevice, pVideoProfile, pCapabilities", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceVideoCapabilitiesKHR(ApiDumpInstance::current(), physicalDevice, pVideoProfile, pCapabilities); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceVideoCapabilitiesKHR(physicalDevice, pVideoProfile, pCapabilities); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceVideoCapabilitiesKHR(ApiDumpInstance::current(), physicalDevice, pVideoProfile, pCapabilities); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceVideoCapabilitiesKHR\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceVideoCapabilitiesKHR(physicalDevice, pVideoProfile, pCapabilities); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoFormatPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceVideoFormatPropertiesKHR", "physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceVideoFormatPropertiesKHR(ApiDumpInstance::current(), physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceVideoFormatPropertiesKHR(physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceVideoFormatPropertiesKHR(ApiDumpInstance::current(), physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceVideoFormatPropertiesKHR\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceVideoFormatPropertiesKHR(physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties); return result; } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceFeatures2KHR", "physicalDevice, pFeatures", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceFeatures2KHR(ApiDumpInstance::current(), physicalDevice, pFeatures); - } - } - instance_dispatch_table(physicalDevice)->GetPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceFeatures2KHR(ApiDumpInstance::current(), physicalDevice, pFeatures); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceFeatures2KHR\n"; } + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures); } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceProperties2KHR", "physicalDevice, pProperties", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceProperties2KHR(ApiDumpInstance::current(), physicalDevice, pProperties); - } - } - instance_dispatch_table(physicalDevice)->GetPhysicalDeviceProperties2KHR(physicalDevice, pProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceProperties2KHR(ApiDumpInstance::current(), physicalDevice, pProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceProperties2KHR\n"; } + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceProperties2KHR(physicalDevice, pProperties); } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceFormatProperties2KHR", "physicalDevice, format, pFormatProperties", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceFormatProperties2KHR(ApiDumpInstance::current(), physicalDevice, format, pFormatProperties); - } - } - instance_dispatch_table(physicalDevice)->GetPhysicalDeviceFormatProperties2KHR(physicalDevice, format, pFormatProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceFormatProperties2KHR(ApiDumpInstance::current(), physicalDevice, format, pFormatProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceFormatProperties2KHR\n"; } + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceFormatProperties2KHR(physicalDevice, format, pFormatProperties); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceImageFormatProperties2KHR", "physicalDevice, pImageFormatInfo, pImageFormatProperties", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceImageFormatProperties2KHR(ApiDumpInstance::current(), physicalDevice, pImageFormatInfo, pImageFormatProperties); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceImageFormatProperties2KHR(physicalDevice, pImageFormatInfo, pImageFormatProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceImageFormatProperties2KHR(ApiDumpInstance::current(), physicalDevice, pImageFormatInfo, pImageFormatProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceImageFormatProperties2KHR\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceImageFormatProperties2KHR(physicalDevice, pImageFormatInfo, pImageFormatProperties); return result; } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceQueueFamilyProperties2KHR", "physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceQueueFamilyProperties2KHR(ApiDumpInstance::current(), physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); - } - } - instance_dispatch_table(physicalDevice)->GetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceQueueFamilyProperties2KHR(ApiDumpInstance::current(), physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceQueueFamilyProperties2KHR\n"; } + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceMemoryProperties2KHR", "physicalDevice, pMemoryProperties", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceMemoryProperties2KHR(ApiDumpInstance::current(), physicalDevice, pMemoryProperties); - } - } - instance_dispatch_table(physicalDevice)->GetPhysicalDeviceMemoryProperties2KHR(physicalDevice, pMemoryProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceMemoryProperties2KHR(ApiDumpInstance::current(), physicalDevice, pMemoryProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceMemoryProperties2KHR\n"; } + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceMemoryProperties2KHR(physicalDevice, pMemoryProperties); } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceSparseImageFormatProperties2KHR", "physicalDevice, pFormatInfo, pPropertyCount, pProperties", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(ApiDumpInstance::current(), physicalDevice, pFormatInfo, pPropertyCount, pProperties); - } - } - instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice, pFormatInfo, pPropertyCount, pProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(ApiDumpInstance::current(), physicalDevice, pFormatInfo, pPropertyCount, pProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceSparseImageFormatProperties2KHR\n"; } + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice, pFormatInfo, pPropertyCount, pProperties); } template VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroupsKHR(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkEnumeratePhysicalDeviceGroupsKHR", "instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkEnumeratePhysicalDeviceGroupsKHR(ApiDumpInstance::current(), instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); - } - } - VkResult result = instance_dispatch_table(instance)->EnumeratePhysicalDeviceGroupsKHR(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkEnumeratePhysicalDeviceGroupsKHR(ApiDumpInstance::current(), instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkEnumeratePhysicalDeviceGroupsKHR\n"; } + VkResult result = instance_dispatch_table(instance)->EnumeratePhysicalDeviceGroupsKHR(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); return result; } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceExternalBufferPropertiesKHR", "physicalDevice, pExternalBufferInfo, pExternalBufferProperties", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceExternalBufferPropertiesKHR(ApiDumpInstance::current(), physicalDevice, pExternalBufferInfo, pExternalBufferProperties); - } - } - instance_dispatch_table(physicalDevice)->GetPhysicalDeviceExternalBufferPropertiesKHR(physicalDevice, pExternalBufferInfo, pExternalBufferProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceExternalBufferPropertiesKHR(ApiDumpInstance::current(), physicalDevice, pExternalBufferInfo, pExternalBufferProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceExternalBufferPropertiesKHR\n"; } + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceExternalBufferPropertiesKHR(physicalDevice, pExternalBufferInfo, pExternalBufferProperties); } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR", "physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(ApiDumpInstance::current(), physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); - } - } - instance_dispatch_table(physicalDevice)->GetPhysicalDeviceExternalSemaphorePropertiesKHR(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(ApiDumpInstance::current(), physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR\n"; } + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceExternalSemaphorePropertiesKHR(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceExternalFencePropertiesKHR", "physicalDevice, pExternalFenceInfo, pExternalFenceProperties", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceExternalFencePropertiesKHR(ApiDumpInstance::current(), physicalDevice, pExternalFenceInfo, pExternalFenceProperties); - } - } - instance_dispatch_table(physicalDevice)->GetPhysicalDeviceExternalFencePropertiesKHR(physicalDevice, pExternalFenceInfo, pExternalFenceProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceExternalFencePropertiesKHR(ApiDumpInstance::current(), physicalDevice, pExternalFenceInfo, pExternalFenceProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceExternalFencePropertiesKHR\n"; } + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceExternalFencePropertiesKHR(physicalDevice, pExternalFenceInfo, pExternalFenceProperties); } template VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR", "physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(ApiDumpInstance::current(), physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->EnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(ApiDumpInstance::current(), physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->EnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions); return result; } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR", "physicalDevice, pPerformanceQueryCreateInfo, pNumPasses", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(ApiDumpInstance::current(), physicalDevice, pPerformanceQueryCreateInfo, pNumPasses); - } - } - instance_dispatch_table(physicalDevice)->GetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(physicalDevice, pPerformanceQueryCreateInfo, pNumPasses); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(ApiDumpInstance::current(), physicalDevice, pPerformanceQueryCreateInfo, pNumPasses); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR\n"; } + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(physicalDevice, pPerformanceQueryCreateInfo, pNumPasses); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceSurfaceCapabilities2KHR", "physicalDevice, pSurfaceInfo, pSurfaceCapabilities", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceSurfaceCapabilities2KHR(ApiDumpInstance::current(), physicalDevice, pSurfaceInfo, pSurfaceCapabilities); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice, pSurfaceInfo, pSurfaceCapabilities); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceSurfaceCapabilities2KHR(ApiDumpInstance::current(), physicalDevice, pSurfaceInfo, pSurfaceCapabilities); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceSurfaceCapabilities2KHR\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice, pSurfaceInfo, pSurfaceCapabilities); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceSurfaceFormats2KHR", "physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceSurfaceFormats2KHR(ApiDumpInstance::current(), physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfaceFormats2KHR(physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceSurfaceFormats2KHR(ApiDumpInstance::current(), physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceSurfaceFormats2KHR\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfaceFormats2KHR(physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceDisplayProperties2KHR", "physicalDevice, pPropertyCount, pProperties", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceDisplayProperties2KHR(ApiDumpInstance::current(), physicalDevice, pPropertyCount, pProperties); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceDisplayProperties2KHR(physicalDevice, pPropertyCount, pProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceDisplayProperties2KHR(ApiDumpInstance::current(), physicalDevice, pPropertyCount, pProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceDisplayProperties2KHR\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceDisplayProperties2KHR(physicalDevice, pPropertyCount, pProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceDisplayPlaneProperties2KHR", "physicalDevice, pPropertyCount, pProperties", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(ApiDumpInstance::current(), physicalDevice, pPropertyCount, pProperties); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceDisplayPlaneProperties2KHR(physicalDevice, pPropertyCount, pProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(ApiDumpInstance::current(), physicalDevice, pPropertyCount, pProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceDisplayPlaneProperties2KHR\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceDisplayPlaneProperties2KHR(physicalDevice, pPropertyCount, pProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDisplayModeProperties2KHR", "physicalDevice, display, pPropertyCount, pProperties", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDisplayModeProperties2KHR(ApiDumpInstance::current(), physicalDevice, display, pPropertyCount, pProperties); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->GetDisplayModeProperties2KHR(physicalDevice, display, pPropertyCount, pProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDisplayModeProperties2KHR(ApiDumpInstance::current(), physicalDevice, display, pPropertyCount, pProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDisplayModeProperties2KHR\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->GetDisplayModeProperties2KHR(physicalDevice, display, pPropertyCount, pProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDisplayPlaneCapabilities2KHR", "physicalDevice, pDisplayPlaneInfo, pCapabilities", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDisplayPlaneCapabilities2KHR(ApiDumpInstance::current(), physicalDevice, pDisplayPlaneInfo, pCapabilities); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->GetDisplayPlaneCapabilities2KHR(physicalDevice, pDisplayPlaneInfo, pCapabilities); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDisplayPlaneCapabilities2KHR(ApiDumpInstance::current(), physicalDevice, pDisplayPlaneInfo, pCapabilities); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDisplayPlaneCapabilities2KHR\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->GetDisplayPlaneCapabilities2KHR(physicalDevice, pDisplayPlaneInfo, pCapabilities); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceFragmentShadingRatesKHR", "physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceFragmentShadingRatesKHR(ApiDumpInstance::current(), physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceFragmentShadingRatesKHR(physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceFragmentShadingRatesKHR(ApiDumpInstance::current(), physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceFragmentShadingRatesKHR\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceFragmentShadingRatesKHR(physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR", "physicalDevice, pQualityLevelInfo, pQualityLevelProperties", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(ApiDumpInstance::current(), physicalDevice, pQualityLevelInfo, pQualityLevelProperties); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(physicalDevice, pQualityLevelInfo, pQualityLevelProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(ApiDumpInstance::current(), physicalDevice, pQualityLevelInfo, pQualityLevelProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(physicalDevice, pQualityLevelInfo, pQualityLevelProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesKHR* pProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR", "physicalDevice, pPropertyCount, pProperties", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(ApiDumpInstance::current(), physicalDevice, pPropertyCount, pProperties); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceCooperativeMatrixPropertiesKHR(physicalDevice, pPropertyCount, pProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(ApiDumpInstance::current(), physicalDevice, pPropertyCount, pProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceCooperativeMatrixPropertiesKHR(physicalDevice, pPropertyCount, pProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainKHR* pTimeDomains) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceCalibrateableTimeDomainsKHR", "physicalDevice, pTimeDomainCount, pTimeDomains", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(ApiDumpInstance::current(), physicalDevice, pTimeDomainCount, pTimeDomains); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceCalibrateableTimeDomainsKHR(physicalDevice, pTimeDomainCount, pTimeDomains); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(ApiDumpInstance::current(), physicalDevice, pTimeDomainCount, pTimeDomains); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceCalibrateableTimeDomainsKHR\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceCalibrateableTimeDomainsKHR(physicalDevice, pTimeDomainCount, pTimeDomains); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateDebugReportCallbackEXT", "instance, pCreateInfo, pAllocator, pCallback", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateDebugReportCallbackEXT(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pCallback); - } - } - VkResult result = instance_dispatch_table(instance)->CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateDebugReportCallbackEXT(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pCallback); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateDebugReportCallbackEXT\n"; } + VkResult result = instance_dispatch_table(instance)->CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyDebugReportCallbackEXT", "instance, callback, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyDebugReportCallbackEXT(ApiDumpInstance::current(), instance, callback, pAllocator); - } - } - instance_dispatch_table(instance)->DestroyDebugReportCallbackEXT(instance, callback, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyDebugReportCallbackEXT(ApiDumpInstance::current(), instance, callback, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyDebugReportCallbackEXT\n"; } + instance_dispatch_table(instance)->DestroyDebugReportCallbackEXT(instance, callback, pAllocator); } template VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDebugReportMessageEXT", "instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDebugReportMessageEXT(ApiDumpInstance::current(), instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage); - } - } - instance_dispatch_table(instance)->DebugReportMessageEXT(instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDebugReportMessageEXT(ApiDumpInstance::current(), instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDebugReportMessageEXT\n"; } + instance_dispatch_table(instance)->DebugReportMessageEXT(instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage); } #if defined(VK_USE_PLATFORM_GGP) template VKAPI_ATTR VkResult VKAPI_CALL vkCreateStreamDescriptorSurfaceGGP(VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateStreamDescriptorSurfaceGGP", "instance, pCreateInfo, pAllocator, pSurface", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateStreamDescriptorSurfaceGGP(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface); - } - } - VkResult result = instance_dispatch_table(instance)->CreateStreamDescriptorSurfaceGGP(instance, pCreateInfo, pAllocator, pSurface); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateStreamDescriptorSurfaceGGP(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateStreamDescriptorSurfaceGGP\n"; } + VkResult result = instance_dispatch_table(instance)->CreateStreamDescriptorSurfaceGGP(instance, pCreateInfo, pAllocator, pSurface); return result; } #endif // VK_USE_PLATFORM_GGP template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceExternalImageFormatPropertiesNV(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceExternalImageFormatPropertiesNV", "physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(ApiDumpInstance::current(), physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceExternalImageFormatPropertiesNV(physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(ApiDumpInstance::current(), physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceExternalImageFormatPropertiesNV\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceExternalImageFormatPropertiesNV(physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties); return result; } #if defined(VK_USE_PLATFORM_VI_NN) template VKAPI_ATTR VkResult VKAPI_CALL vkCreateViSurfaceNN(VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateViSurfaceNN", "instance, pCreateInfo, pAllocator, pSurface", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateViSurfaceNN(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface); - } - } - VkResult result = instance_dispatch_table(instance)->CreateViSurfaceNN(instance, pCreateInfo, pAllocator, pSurface); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateViSurfaceNN(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateViSurfaceNN\n"; } + VkResult result = instance_dispatch_table(instance)->CreateViSurfaceNN(instance, pCreateInfo, pAllocator, pSurface); return result; } #endif // VK_USE_PLATFORM_VI_NN template VKAPI_ATTR VkResult VKAPI_CALL vkReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkReleaseDisplayEXT", "physicalDevice, display", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkReleaseDisplayEXT(ApiDumpInstance::current(), physicalDevice, display); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->ReleaseDisplayEXT(physicalDevice, display); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkReleaseDisplayEXT(ApiDumpInstance::current(), physicalDevice, display); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkReleaseDisplayEXT\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->ReleaseDisplayEXT(physicalDevice, display); return result; } #if defined(VK_USE_PLATFORM_XLIB_XRANDR_EXT) template VKAPI_ATTR VkResult VKAPI_CALL vkAcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkAcquireXlibDisplayEXT", "physicalDevice, dpy, display", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkAcquireXlibDisplayEXT(ApiDumpInstance::current(), physicalDevice, dpy, display); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->AcquireXlibDisplayEXT(physicalDevice, dpy, display); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkAcquireXlibDisplayEXT(ApiDumpInstance::current(), physicalDevice, dpy, display); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkAcquireXlibDisplayEXT\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->AcquireXlibDisplayEXT(physicalDevice, dpy, display); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetRandROutputDisplayEXT", "physicalDevice, dpy, rrOutput, pDisplay", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetRandROutputDisplayEXT(ApiDumpInstance::current(), physicalDevice, dpy, rrOutput, pDisplay); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->GetRandROutputDisplayEXT(physicalDevice, dpy, rrOutput, pDisplay); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetRandROutputDisplayEXT(ApiDumpInstance::current(), physicalDevice, dpy, rrOutput, pDisplay); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetRandROutputDisplayEXT\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->GetRandROutputDisplayEXT(physicalDevice, dpy, rrOutput, pDisplay); return result; } #endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceSurfaceCapabilities2EXT", "physicalDevice, surface, pSurfaceCapabilities", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceSurfaceCapabilities2EXT(ApiDumpInstance::current(), physicalDevice, surface, pSurfaceCapabilities); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice, surface, pSurfaceCapabilities); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceSurfaceCapabilities2EXT(ApiDumpInstance::current(), physicalDevice, surface, pSurfaceCapabilities); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceSurfaceCapabilities2EXT\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice, surface, pSurfaceCapabilities); return result; } #if defined(VK_USE_PLATFORM_IOS_MVK) template VKAPI_ATTR VkResult VKAPI_CALL vkCreateIOSSurfaceMVK(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateIOSSurfaceMVK", "instance, pCreateInfo, pAllocator, pSurface", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateIOSSurfaceMVK(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface); - } - } - VkResult result = instance_dispatch_table(instance)->CreateIOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateIOSSurfaceMVK(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateIOSSurfaceMVK\n"; } + VkResult result = instance_dispatch_table(instance)->CreateIOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface); return result; } #endif // VK_USE_PLATFORM_IOS_MVK @@ -1577,157 +737,72 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateIOSSurfaceMVK(VkInstance instance, const template VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateMacOSSurfaceMVK", "instance, pCreateInfo, pAllocator, pSurface", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateMacOSSurfaceMVK(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface); - } - } - VkResult result = instance_dispatch_table(instance)->CreateMacOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateMacOSSurfaceMVK(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateMacOSSurfaceMVK\n"; } + VkResult result = instance_dispatch_table(instance)->CreateMacOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface); return result; } #endif // VK_USE_PLATFORM_MACOS_MVK template VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateDebugUtilsMessengerEXT", "instance, pCreateInfo, pAllocator, pMessenger", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateDebugUtilsMessengerEXT(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pMessenger); - } - } - VkResult result = instance_dispatch_table(instance)->CreateDebugUtilsMessengerEXT(instance, pCreateInfo, pAllocator, pMessenger); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateDebugUtilsMessengerEXT(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pMessenger); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateDebugUtilsMessengerEXT\n"; } + VkResult result = instance_dispatch_table(instance)->CreateDebugUtilsMessengerEXT(instance, pCreateInfo, pAllocator, pMessenger); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyDebugUtilsMessengerEXT", "instance, messenger, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyDebugUtilsMessengerEXT(ApiDumpInstance::current(), instance, messenger, pAllocator); - } - } - instance_dispatch_table(instance)->DestroyDebugUtilsMessengerEXT(instance, messenger, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyDebugUtilsMessengerEXT(ApiDumpInstance::current(), instance, messenger, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyDebugUtilsMessengerEXT\n"; } + instance_dispatch_table(instance)->DestroyDebugUtilsMessengerEXT(instance, messenger, pAllocator); } template VKAPI_ATTR void VKAPI_CALL vkSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkSubmitDebugUtilsMessageEXT", "instance, messageSeverity, messageTypes, pCallbackData", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkSubmitDebugUtilsMessageEXT(ApiDumpInstance::current(), instance, messageSeverity, messageTypes, pCallbackData); - } - } - instance_dispatch_table(instance)->SubmitDebugUtilsMessageEXT(instance, messageSeverity, messageTypes, pCallbackData); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkSubmitDebugUtilsMessageEXT(ApiDumpInstance::current(), instance, messageSeverity, messageTypes, pCallbackData); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkSubmitDebugUtilsMessageEXT\n"; } + instance_dispatch_table(instance)->SubmitDebugUtilsMessageEXT(instance, messageSeverity, messageTypes, pCallbackData); } template VKAPI_ATTR VkDeviceSize VKAPI_CALL vkGetPhysicalDeviceDescriptorSizeEXT(VkPhysicalDevice physicalDevice, VkDescriptorType descriptorType) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceDescriptorSizeEXT", "physicalDevice, descriptorType", "VkDeviceSize"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceDescriptorSizeEXT(ApiDumpInstance::current(), physicalDevice, descriptorType); - } - } - VkDeviceSize result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceDescriptorSizeEXT(physicalDevice, descriptorType); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkDeviceSize", result); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceDescriptorSizeEXT(ApiDumpInstance::current(), physicalDevice, descriptorType); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceDescriptorSizeEXT\n"; } + VkDeviceSize result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceDescriptorSizeEXT(physicalDevice, descriptorType); return result; } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceMultisamplePropertiesEXT", "physicalDevice, samples, pMultisampleProperties", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceMultisamplePropertiesEXT(ApiDumpInstance::current(), physicalDevice, samples, pMultisampleProperties); - } - } - instance_dispatch_table(physicalDevice)->GetPhysicalDeviceMultisamplePropertiesEXT(physicalDevice, samples, pMultisampleProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceMultisamplePropertiesEXT(ApiDumpInstance::current(), physicalDevice, samples, pMultisampleProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceMultisamplePropertiesEXT\n"; } + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceMultisamplePropertiesEXT(physicalDevice, samples, pMultisampleProperties); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainKHR* pTimeDomains) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT", "physicalDevice, pTimeDomainCount, pTimeDomains", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(ApiDumpInstance::current(), physicalDevice, pTimeDomainCount, pTimeDomains); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceCalibrateableTimeDomainsEXT(physicalDevice, pTimeDomainCount, pTimeDomains); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(ApiDumpInstance::current(), physicalDevice, pTimeDomainCount, pTimeDomains); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceCalibrateableTimeDomainsEXT(physicalDevice, pTimeDomainCount, pTimeDomains); return result; } #if defined(VK_USE_PLATFORM_FUCHSIA) template VKAPI_ATTR VkResult VKAPI_CALL vkCreateImagePipeSurfaceFUCHSIA(VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateImagePipeSurfaceFUCHSIA", "instance, pCreateInfo, pAllocator, pSurface", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateImagePipeSurfaceFUCHSIA(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface); - } - } - VkResult result = instance_dispatch_table(instance)->CreateImagePipeSurfaceFUCHSIA(instance, pCreateInfo, pAllocator, pSurface); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateImagePipeSurfaceFUCHSIA(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateImagePipeSurfaceFUCHSIA\n"; } + VkResult result = instance_dispatch_table(instance)->CreateImagePipeSurfaceFUCHSIA(instance, pCreateInfo, pAllocator, pSurface); return result; } #endif // VK_USE_PLATFORM_FUCHSIA @@ -1735,33 +810,18 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateImagePipeSurfaceFUCHSIA(VkInstance instan template VKAPI_ATTR VkResult VKAPI_CALL vkCreateMetalSurfaceEXT(VkInstance instance, const VkMetalSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateMetalSurfaceEXT", "instance, pCreateInfo, pAllocator, pSurface", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateMetalSurfaceEXT(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface); - } - } - VkResult result = instance_dispatch_table(instance)->CreateMetalSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateMetalSurfaceEXT(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateMetalSurfaceEXT\n"; } + VkResult result = instance_dispatch_table(instance)->CreateMetalSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface); return result; } #endif // VK_USE_PLATFORM_METAL_EXT template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceToolPropertiesEXT(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceToolPropertiesEXT", "physicalDevice, pToolCount, pToolProperties", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceToolPropertiesEXT(ApiDumpInstance::current(), physicalDevice, pToolCount, pToolProperties); - } + if (ApiDumpInstance::current().shouldDumpOutput()) { + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceToolPropertiesEXT\n"; } static const VkPhysicalDeviceToolPropertiesEXT api_dump_layer_tool_props = { @@ -1785,176 +845,81 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceToolPropertiesEXT(VkPhysicalDe } (*pToolCount)++; - if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceToolPropertiesEXT(ApiDumpInstance::current(), physicalDevice, pToolCount, pToolProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); - } return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV", "physicalDevice, pPropertyCount, pProperties", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(ApiDumpInstance::current(), physicalDevice, pPropertyCount, pProperties); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceCooperativeMatrixPropertiesNV(physicalDevice, pPropertyCount, pProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(ApiDumpInstance::current(), physicalDevice, pPropertyCount, pProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceCooperativeMatrixPropertiesNV(physicalDevice, pPropertyCount, pProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV", "physicalDevice, pCombinationCount, pCombinations", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(ApiDumpInstance::current(), physicalDevice, pCombinationCount, pCombinations); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(physicalDevice, pCombinationCount, pCombinations); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(ApiDumpInstance::current(), physicalDevice, pCombinationCount, pCombinations); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(physicalDevice, pCombinationCount, pCombinations); return result; } #if defined(VK_USE_PLATFORM_WIN32_KHR) template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModes2EXT(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceSurfacePresentModes2EXT", "physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceSurfacePresentModes2EXT(ApiDumpInstance::current(), physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfacePresentModes2EXT(physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceSurfacePresentModes2EXT(ApiDumpInstance::current(), physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceSurfacePresentModes2EXT\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfacePresentModes2EXT(physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes); return result; } #endif // VK_USE_PLATFORM_WIN32_KHR template VKAPI_ATTR VkResult VKAPI_CALL vkCreateHeadlessSurfaceEXT(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateHeadlessSurfaceEXT", "instance, pCreateInfo, pAllocator, pSurface", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateHeadlessSurfaceEXT(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface); - } - } - VkResult result = instance_dispatch_table(instance)->CreateHeadlessSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateHeadlessSurfaceEXT(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateHeadlessSurfaceEXT\n"; } + VkResult result = instance_dispatch_table(instance)->CreateHeadlessSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkAcquireDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkAcquireDrmDisplayEXT", "physicalDevice, drmFd, display", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkAcquireDrmDisplayEXT(ApiDumpInstance::current(), physicalDevice, drmFd, display); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->AcquireDrmDisplayEXT(physicalDevice, drmFd, display); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkAcquireDrmDisplayEXT(ApiDumpInstance::current(), physicalDevice, drmFd, display); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkAcquireDrmDisplayEXT\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->AcquireDrmDisplayEXT(physicalDevice, drmFd, display); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR* display) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDrmDisplayEXT", "physicalDevice, drmFd, connectorId, display", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDrmDisplayEXT(ApiDumpInstance::current(), physicalDevice, drmFd, connectorId, display); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->GetDrmDisplayEXT(physicalDevice, drmFd, connectorId, display); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDrmDisplayEXT(ApiDumpInstance::current(), physicalDevice, drmFd, connectorId, display); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDrmDisplayEXT\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->GetDrmDisplayEXT(physicalDevice, drmFd, connectorId, display); return result; } #if defined(VK_USE_PLATFORM_WIN32_KHR) template VKAPI_ATTR VkResult VKAPI_CALL vkAcquireWinrtDisplayNV(VkPhysicalDevice physicalDevice, VkDisplayKHR display) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkAcquireWinrtDisplayNV", "physicalDevice, display", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkAcquireWinrtDisplayNV(ApiDumpInstance::current(), physicalDevice, display); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->AcquireWinrtDisplayNV(physicalDevice, display); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkAcquireWinrtDisplayNV(ApiDumpInstance::current(), physicalDevice, display); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkAcquireWinrtDisplayNV\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->AcquireWinrtDisplayNV(physicalDevice, display); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetWinrtDisplayNV(VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR* pDisplay) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetWinrtDisplayNV", "physicalDevice, deviceRelativeId, pDisplay", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetWinrtDisplayNV(ApiDumpInstance::current(), physicalDevice, deviceRelativeId, pDisplay); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->GetWinrtDisplayNV(physicalDevice, deviceRelativeId, pDisplay); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetWinrtDisplayNV(ApiDumpInstance::current(), physicalDevice, deviceRelativeId, pDisplay); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetWinrtDisplayNV\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->GetWinrtDisplayNV(physicalDevice, deviceRelativeId, pDisplay); return result; } #endif // VK_USE_PLATFORM_WIN32_KHR @@ -1962,41 +927,19 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetWinrtDisplayNV(VkPhysicalDevice physicalDevi template VKAPI_ATTR VkResult VKAPI_CALL vkCreateDirectFBSurfaceEXT(VkInstance instance, const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateDirectFBSurfaceEXT", "instance, pCreateInfo, pAllocator, pSurface", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateDirectFBSurfaceEXT(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface); - } - } - VkResult result = instance_dispatch_table(instance)->CreateDirectFBSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateDirectFBSurfaceEXT(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateDirectFBSurfaceEXT\n"; } + VkResult result = instance_dispatch_table(instance)->CreateDirectFBSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface); return result; } template VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceDirectFBPresentationSupportEXT(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, IDirectFB* dfb) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceDirectFBPresentationSupportEXT", "physicalDevice, queueFamilyIndex, dfb", "VkBool32"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceDirectFBPresentationSupportEXT(ApiDumpInstance::current(), physicalDevice, queueFamilyIndex, dfb); - } - } - VkBool32 result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceDirectFBPresentationSupportEXT(physicalDevice, queueFamilyIndex, dfb); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkBool32", result); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceDirectFBPresentationSupportEXT(ApiDumpInstance::current(), physicalDevice, queueFamilyIndex, dfb); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceDirectFBPresentationSupportEXT\n"; } + VkBool32 result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceDirectFBPresentationSupportEXT(physicalDevice, queueFamilyIndex, dfb); return result; } #endif // VK_USE_PLATFORM_DIRECTFB_EXT @@ -2004,200 +947,92 @@ VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceDirectFBPresentationSupportEXT template VKAPI_ATTR VkResult VKAPI_CALL vkCreateScreenSurfaceQNX(VkInstance instance, const VkScreenSurfaceCreateInfoQNX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateScreenSurfaceQNX", "instance, pCreateInfo, pAllocator, pSurface", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateScreenSurfaceQNX(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface); - } - } - VkResult result = instance_dispatch_table(instance)->CreateScreenSurfaceQNX(instance, pCreateInfo, pAllocator, pSurface); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateScreenSurfaceQNX(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateScreenSurfaceQNX\n"; } + VkResult result = instance_dispatch_table(instance)->CreateScreenSurfaceQNX(instance, pCreateInfo, pAllocator, pSurface); return result; } template VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceScreenPresentationSupportQNX(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct _screen_window* window) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceScreenPresentationSupportQNX", "physicalDevice, queueFamilyIndex, window", "VkBool32"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceScreenPresentationSupportQNX(ApiDumpInstance::current(), physicalDevice, queueFamilyIndex, window); - } - } - VkBool32 result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceScreenPresentationSupportQNX(physicalDevice, queueFamilyIndex, window); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkBool32", result); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceScreenPresentationSupportQNX(ApiDumpInstance::current(), physicalDevice, queueFamilyIndex, window); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceScreenPresentationSupportQNX\n"; } + VkBool32 result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceScreenPresentationSupportQNX(physicalDevice, queueFamilyIndex, window); return result; } #endif // VK_USE_PLATFORM_SCREEN_QNX template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalTensorPropertiesARM(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalTensorInfoARM* pExternalTensorInfo, VkExternalTensorPropertiesARM* pExternalTensorProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceExternalTensorPropertiesARM", "physicalDevice, pExternalTensorInfo, pExternalTensorProperties", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceExternalTensorPropertiesARM(ApiDumpInstance::current(), physicalDevice, pExternalTensorInfo, pExternalTensorProperties); - } - } - instance_dispatch_table(physicalDevice)->GetPhysicalDeviceExternalTensorPropertiesARM(physicalDevice, pExternalTensorInfo, pExternalTensorProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceExternalTensorPropertiesARM(ApiDumpInstance::current(), physicalDevice, pExternalTensorInfo, pExternalTensorProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceExternalTensorPropertiesARM\n"; } + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceExternalTensorPropertiesARM(physicalDevice, pExternalTensorInfo, pExternalTensorProperties); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceOpticalFlowImageFormatsNV(VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, uint32_t* pFormatCount, VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceOpticalFlowImageFormatsNV", "physicalDevice, pOpticalFlowImageFormatInfo, pFormatCount, pImageFormatProperties", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(ApiDumpInstance::current(), physicalDevice, pOpticalFlowImageFormatInfo, pFormatCount, pImageFormatProperties); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceOpticalFlowImageFormatsNV(physicalDevice, pOpticalFlowImageFormatInfo, pFormatCount, pImageFormatProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(ApiDumpInstance::current(), physicalDevice, pOpticalFlowImageFormatInfo, pFormatCount, pImageFormatProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceOpticalFlowImageFormatsNV\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceOpticalFlowImageFormatsNV(physicalDevice, pOpticalFlowImageFormatInfo, pFormatCount, pImageFormatProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeVectorPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeVectorPropertiesNV* pProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceCooperativeVectorPropertiesNV", "physicalDevice, pPropertyCount, pProperties", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceCooperativeVectorPropertiesNV(ApiDumpInstance::current(), physicalDevice, pPropertyCount, pProperties); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceCooperativeVectorPropertiesNV(physicalDevice, pPropertyCount, pProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceCooperativeVectorPropertiesNV(ApiDumpInstance::current(), physicalDevice, pPropertyCount, pProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceCooperativeVectorPropertiesNV\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceCooperativeVectorPropertiesNV(physicalDevice, pPropertyCount, pProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pQueueFamilyDataGraphPropertyCount, VkQueueFamilyDataGraphPropertiesARM* pQueueFamilyDataGraphProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM", "physicalDevice, queueFamilyIndex, pQueueFamilyDataGraphPropertyCount, pQueueFamilyDataGraphProperties", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM(ApiDumpInstance::current(), physicalDevice, queueFamilyIndex, pQueueFamilyDataGraphPropertyCount, pQueueFamilyDataGraphProperties); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceQueueFamilyDataGraphPropertiesARM(physicalDevice, queueFamilyIndex, pQueueFamilyDataGraphPropertyCount, pQueueFamilyDataGraphProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM(ApiDumpInstance::current(), physicalDevice, queueFamilyIndex, pQueueFamilyDataGraphPropertyCount, pQueueFamilyDataGraphProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceQueueFamilyDataGraphPropertiesARM(physicalDevice, queueFamilyIndex, pQueueFamilyDataGraphPropertyCount, pQueueFamilyDataGraphProperties); return result; } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM* pQueueFamilyDataGraphProcessingEngineInfo, VkQueueFamilyDataGraphProcessingEnginePropertiesARM* pQueueFamilyDataGraphProcessingEngineProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM", "physicalDevice, pQueueFamilyDataGraphProcessingEngineInfo, pQueueFamilyDataGraphProcessingEngineProperties", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM(ApiDumpInstance::current(), physicalDevice, pQueueFamilyDataGraphProcessingEngineInfo, pQueueFamilyDataGraphProcessingEngineProperties); - } - } - instance_dispatch_table(physicalDevice)->GetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM(physicalDevice, pQueueFamilyDataGraphProcessingEngineInfo, pQueueFamilyDataGraphProcessingEngineProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM(ApiDumpInstance::current(), physicalDevice, pQueueFamilyDataGraphProcessingEngineInfo, pQueueFamilyDataGraphProcessingEngineProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM\n"; } + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM(physicalDevice, pQueueFamilyDataGraphProcessingEngineInfo, pQueueFamilyDataGraphProcessingEngineProperties); } #if defined(VK_USE_PLATFORM_OHOS) template VKAPI_ATTR VkResult VKAPI_CALL vkCreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateSurfaceOHOS", "instance, pCreateInfo, pAllocator, pSurface", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateSurfaceOHOS(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface); - } - } - VkResult result = instance_dispatch_table(instance)->CreateSurfaceOHOS(instance, pCreateInfo, pAllocator, pSurface); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateSurfaceOHOS(ApiDumpInstance::current(), instance, pCreateInfo, pAllocator, pSurface); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateSurfaceOHOS\n"; } + VkResult result = instance_dispatch_table(instance)->CreateSurfaceOHOS(instance, pCreateInfo, pAllocator, pSurface); return result; } #endif // VK_USE_PLATFORM_OHOS template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixFlexibleDimensionsPropertiesNV* pProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV", "physicalDevice, pPropertyCount, pProperties", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(ApiDumpInstance::current(), physicalDevice, pPropertyCount, pProperties); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(physicalDevice, pPropertyCount, pProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(ApiDumpInstance::current(), physicalDevice, pPropertyCount, pProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(physicalDevice, pPropertyCount, pProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterARM* pCounters, VkPerformanceCounterDescriptionARM* pCounterDescriptions) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM", "physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM(ApiDumpInstance::current(), physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions); - } - } - VkResult result = instance_dispatch_table(physicalDevice)->EnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM(physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM(ApiDumpInstance::current(), physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM\n"; } + VkResult result = instance_dispatch_table(physicalDevice)->EnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM(physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions); return result; } @@ -2207,73 +1042,37 @@ template VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyDevice", "device, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyDevice(ApiDumpInstance::current(), device, pAllocator); - } + if (ApiDumpInstance::current().shouldDumpOutput()) { + ApiDumpInstance::current().settings().stream() << "vkDestroyDevice\n"; } device_dispatch_table(device)->DestroyDevice(device, pAllocator); destroy_device_dispatch_table(get_dispatch_key(device)); - if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyDevice(ApiDumpInstance::current(), device, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); - } } template VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDeviceQueue", "device, queueFamilyIndex, queueIndex, pQueue", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceQueue(ApiDumpInstance::current(), device, queueFamilyIndex, queueIndex, pQueue); - } - } - device_dispatch_table(device)->GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceQueue(ApiDumpInstance::current(), device, queueFamilyIndex, queueIndex, pQueue); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDeviceQueue\n"; } + device_dispatch_table(device)->GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue); } template VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkQueueSubmit", "queue, submitCount, pSubmits, fence", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkQueueSubmit(ApiDumpInstance::current(), queue, submitCount, pSubmits, fence); - } - } - VkResult result = device_dispatch_table(queue)->QueueSubmit(queue, submitCount, pSubmits, fence); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkQueueSubmit(ApiDumpInstance::current(), queue, submitCount, pSubmits, fence); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkQueueSubmit\n"; } + VkResult result = device_dispatch_table(queue)->QueueSubmit(queue, submitCount, pSubmits, fence); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle(VkQueue queue) { VkResult result = device_dispatch_table(queue)->QueueWaitIdle(queue); std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkQueueWaitIdle", "queue", "VkResult"); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkQueueWaitIdle(ApiDumpInstance::current(), queue); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkQueueWaitIdle\n"; } return result; } @@ -2281,13 +1080,8 @@ template VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(VkDevice device) { VkResult result = device_dispatch_table(device)->DeviceWaitIdle(device); std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDeviceWaitIdle", "device", "VkResult"); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDeviceWaitIdle(ApiDumpInstance::current(), device); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDeviceWaitIdle\n"; } return result; } @@ -2295,356 +1089,171 @@ template VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkAllocateMemory", "device, pAllocateInfo, pAllocator, pMemory", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkAllocateMemory(ApiDumpInstance::current(), device, pAllocateInfo, pAllocator, pMemory); - } - } - VkResult result = device_dispatch_table(device)->AllocateMemory(device, pAllocateInfo, pAllocator, pMemory); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkAllocateMemory(ApiDumpInstance::current(), device, pAllocateInfo, pAllocator, pMemory); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkAllocateMemory\n"; } + VkResult result = device_dispatch_table(device)->AllocateMemory(device, pAllocateInfo, pAllocator, pMemory); return result; } template VKAPI_ATTR void VKAPI_CALL vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkFreeMemory", "device, memory, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkFreeMemory(ApiDumpInstance::current(), device, memory, pAllocator); - } - } - device_dispatch_table(device)->FreeMemory(device, memory, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkFreeMemory(ApiDumpInstance::current(), device, memory, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkFreeMemory\n"; } + device_dispatch_table(device)->FreeMemory(device, memory, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkMapMemory", "device, memory, offset, size, flags, ppData", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkMapMemory(ApiDumpInstance::current(), device, memory, offset, size, flags, ppData); - } - } - VkResult result = device_dispatch_table(device)->MapMemory(device, memory, offset, size, flags, ppData); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkMapMemory(ApiDumpInstance::current(), device, memory, offset, size, flags, ppData); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkMapMemory\n"; } + VkResult result = device_dispatch_table(device)->MapMemory(device, memory, offset, size, flags, ppData); return result; } template VKAPI_ATTR void VKAPI_CALL vkUnmapMemory(VkDevice device, VkDeviceMemory memory) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkUnmapMemory", "device, memory", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkUnmapMemory(ApiDumpInstance::current(), device, memory); - } - } - device_dispatch_table(device)->UnmapMemory(device, memory); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkUnmapMemory(ApiDumpInstance::current(), device, memory); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkUnmapMemory\n"; } + device_dispatch_table(device)->UnmapMemory(device, memory); } template VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkFlushMappedMemoryRanges", "device, memoryRangeCount, pMemoryRanges", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkFlushMappedMemoryRanges(ApiDumpInstance::current(), device, memoryRangeCount, pMemoryRanges); - } - } - VkResult result = device_dispatch_table(device)->FlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkFlushMappedMemoryRanges(ApiDumpInstance::current(), device, memoryRangeCount, pMemoryRanges); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkFlushMappedMemoryRanges\n"; } + VkResult result = device_dispatch_table(device)->FlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkInvalidateMappedMemoryRanges", "device, memoryRangeCount, pMemoryRanges", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkInvalidateMappedMemoryRanges(ApiDumpInstance::current(), device, memoryRangeCount, pMemoryRanges); - } - } - VkResult result = device_dispatch_table(device)->InvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkInvalidateMappedMemoryRanges(ApiDumpInstance::current(), device, memoryRangeCount, pMemoryRanges); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkInvalidateMappedMemoryRanges\n"; } + VkResult result = device_dispatch_table(device)->InvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); return result; } template VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDeviceMemoryCommitment", "device, memory, pCommittedMemoryInBytes", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceMemoryCommitment(ApiDumpInstance::current(), device, memory, pCommittedMemoryInBytes); - } - } - device_dispatch_table(device)->GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceMemoryCommitment(ApiDumpInstance::current(), device, memory, pCommittedMemoryInBytes); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDeviceMemoryCommitment\n"; } + device_dispatch_table(device)->GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes); } template VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkBindBufferMemory", "device, buffer, memory, memoryOffset", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkBindBufferMemory(ApiDumpInstance::current(), device, buffer, memory, memoryOffset); - } - } - VkResult result = device_dispatch_table(device)->BindBufferMemory(device, buffer, memory, memoryOffset); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkBindBufferMemory(ApiDumpInstance::current(), device, buffer, memory, memoryOffset); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkBindBufferMemory\n"; } + VkResult result = device_dispatch_table(device)->BindBufferMemory(device, buffer, memory, memoryOffset); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkBindImageMemory", "device, image, memory, memoryOffset", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkBindImageMemory(ApiDumpInstance::current(), device, image, memory, memoryOffset); - } - } - VkResult result = device_dispatch_table(device)->BindImageMemory(device, image, memory, memoryOffset); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkBindImageMemory(ApiDumpInstance::current(), device, image, memory, memoryOffset); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkBindImageMemory\n"; } + VkResult result = device_dispatch_table(device)->BindImageMemory(device, image, memory, memoryOffset); return result; } template VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetBufferMemoryRequirements", "device, buffer, pMemoryRequirements", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetBufferMemoryRequirements(ApiDumpInstance::current(), device, buffer, pMemoryRequirements); - } - } - device_dispatch_table(device)->GetBufferMemoryRequirements(device, buffer, pMemoryRequirements); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetBufferMemoryRequirements(ApiDumpInstance::current(), device, buffer, pMemoryRequirements); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetBufferMemoryRequirements\n"; } + device_dispatch_table(device)->GetBufferMemoryRequirements(device, buffer, pMemoryRequirements); } template VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetImageMemoryRequirements", "device, image, pMemoryRequirements", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetImageMemoryRequirements(ApiDumpInstance::current(), device, image, pMemoryRequirements); - } - } - device_dispatch_table(device)->GetImageMemoryRequirements(device, image, pMemoryRequirements); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetImageMemoryRequirements(ApiDumpInstance::current(), device, image, pMemoryRequirements); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetImageMemoryRequirements\n"; } + device_dispatch_table(device)->GetImageMemoryRequirements(device, image, pMemoryRequirements); } template VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetImageSparseMemoryRequirements", "device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetImageSparseMemoryRequirements(ApiDumpInstance::current(), device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements); - } - } - device_dispatch_table(device)->GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetImageSparseMemoryRequirements(ApiDumpInstance::current(), device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetImageSparseMemoryRequirements\n"; } + device_dispatch_table(device)->GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements); } template VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkQueueBindSparse", "queue, bindInfoCount, pBindInfo, fence", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkQueueBindSparse(ApiDumpInstance::current(), queue, bindInfoCount, pBindInfo, fence); - } - } - VkResult result = device_dispatch_table(queue)->QueueBindSparse(queue, bindInfoCount, pBindInfo, fence); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkQueueBindSparse(ApiDumpInstance::current(), queue, bindInfoCount, pBindInfo, fence); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkQueueBindSparse\n"; } + VkResult result = device_dispatch_table(queue)->QueueBindSparse(queue, bindInfoCount, pBindInfo, fence); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateFence", "device, pCreateInfo, pAllocator, pFence", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateFence(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pFence); - } - } - VkResult result = device_dispatch_table(device)->CreateFence(device, pCreateInfo, pAllocator, pFence); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateFence(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pFence); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateFence\n"; } + VkResult result = device_dispatch_table(device)->CreateFence(device, pCreateInfo, pAllocator, pFence); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyFence", "device, fence, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyFence(ApiDumpInstance::current(), device, fence, pAllocator); - } - } - device_dispatch_table(device)->DestroyFence(device, fence, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyFence(ApiDumpInstance::current(), device, fence, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyFence\n"; } + device_dispatch_table(device)->DestroyFence(device, fence, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkResetFences", "device, fenceCount, pFences", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkResetFences(ApiDumpInstance::current(), device, fenceCount, pFences); - } - } - VkResult result = device_dispatch_table(device)->ResetFences(device, fenceCount, pFences); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkResetFences(ApiDumpInstance::current(), device, fenceCount, pFences); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkResetFences\n"; } + VkResult result = device_dispatch_table(device)->ResetFences(device, fenceCount, pFences); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus(VkDevice device, VkFence fence) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetFenceStatus", "device, fence", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetFenceStatus(ApiDumpInstance::current(), device, fence); - } - } - VkResult result = device_dispatch_table(device)->GetFenceStatus(device, fence); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetFenceStatus(ApiDumpInstance::current(), device, fence); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetFenceStatus\n"; } + VkResult result = device_dispatch_table(device)->GetFenceStatus(device, fence); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) { VkResult result = device_dispatch_table(device)->WaitForFences(device, fenceCount, pFences, waitAll, timeout); std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkWaitForFences", "device, fenceCount, pFences, waitAll, timeout", "VkResult"); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkWaitForFences(ApiDumpInstance::current(), device, fenceCount, pFences, waitAll, timeout); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkWaitForFences\n"; } return result; } @@ -2652,93 +1261,46 @@ template VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateSemaphore", "device, pCreateInfo, pAllocator, pSemaphore", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateSemaphore(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pSemaphore); - } - } - VkResult result = device_dispatch_table(device)->CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateSemaphore(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pSemaphore); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateSemaphore\n"; } + VkResult result = device_dispatch_table(device)->CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroySemaphore", "device, semaphore, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroySemaphore(ApiDumpInstance::current(), device, semaphore, pAllocator); - } - } - device_dispatch_table(device)->DestroySemaphore(device, semaphore, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroySemaphore(ApiDumpInstance::current(), device, semaphore, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroySemaphore\n"; } + device_dispatch_table(device)->DestroySemaphore(device, semaphore, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateQueryPool", "device, pCreateInfo, pAllocator, pQueryPool", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateQueryPool(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pQueryPool); - } - } - VkResult result = device_dispatch_table(device)->CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateQueryPool(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pQueryPool); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateQueryPool\n"; } + VkResult result = device_dispatch_table(device)->CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyQueryPool", "device, queryPool, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyQueryPool(ApiDumpInstance::current(), device, queryPool, pAllocator); - } - } - device_dispatch_table(device)->DestroyQueryPool(device, queryPool, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyQueryPool(ApiDumpInstance::current(), device, queryPool, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyQueryPool\n"; } + device_dispatch_table(device)->DestroyQueryPool(device, queryPool, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) { VkResult result = device_dispatch_table(device)->GetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags); std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetQueryPoolResults", "device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags", "VkResult"); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetQueryPoolResults(ApiDumpInstance::current(), device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetQueryPoolResults\n"; } return result; } @@ -2746,213 +1308,104 @@ template VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateBuffer", "device, pCreateInfo, pAllocator, pBuffer", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateBuffer(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pBuffer); - } - } - VkResult result = device_dispatch_table(device)->CreateBuffer(device, pCreateInfo, pAllocator, pBuffer); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateBuffer(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pBuffer); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateBuffer\n"; } + VkResult result = device_dispatch_table(device)->CreateBuffer(device, pCreateInfo, pAllocator, pBuffer); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyBuffer", "device, buffer, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyBuffer(ApiDumpInstance::current(), device, buffer, pAllocator); - } - } - device_dispatch_table(device)->DestroyBuffer(device, buffer, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyBuffer(ApiDumpInstance::current(), device, buffer, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyBuffer\n"; } + device_dispatch_table(device)->DestroyBuffer(device, buffer, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateImage", "device, pCreateInfo, pAllocator, pImage", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateImage(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pImage); - } - } - VkResult result = device_dispatch_table(device)->CreateImage(device, pCreateInfo, pAllocator, pImage); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateImage(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pImage); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateImage\n"; } + VkResult result = device_dispatch_table(device)->CreateImage(device, pCreateInfo, pAllocator, pImage); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyImage", "device, image, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyImage(ApiDumpInstance::current(), device, image, pAllocator); - } - } - device_dispatch_table(device)->DestroyImage(device, image, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyImage(ApiDumpInstance::current(), device, image, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyImage\n"; } + device_dispatch_table(device)->DestroyImage(device, image, pAllocator); } template VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetImageSubresourceLayout", "device, image, pSubresource, pLayout", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetImageSubresourceLayout(ApiDumpInstance::current(), device, image, pSubresource, pLayout); - } - } - device_dispatch_table(device)->GetImageSubresourceLayout(device, image, pSubresource, pLayout); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetImageSubresourceLayout(ApiDumpInstance::current(), device, image, pSubresource, pLayout); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetImageSubresourceLayout\n"; } + device_dispatch_table(device)->GetImageSubresourceLayout(device, image, pSubresource, pLayout); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateImageView", "device, pCreateInfo, pAllocator, pView", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateImageView(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pView); - } - } - VkResult result = device_dispatch_table(device)->CreateImageView(device, pCreateInfo, pAllocator, pView); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateImageView(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pView); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateImageView\n"; } + VkResult result = device_dispatch_table(device)->CreateImageView(device, pCreateInfo, pAllocator, pView); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyImageView", "device, imageView, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyImageView(ApiDumpInstance::current(), device, imageView, pAllocator); - } - } - device_dispatch_table(device)->DestroyImageView(device, imageView, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyImageView(ApiDumpInstance::current(), device, imageView, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyImageView\n"; } + device_dispatch_table(device)->DestroyImageView(device, imageView, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateCommandPool", "device, pCreateInfo, pAllocator, pCommandPool", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateCommandPool(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pCommandPool); - } - } - VkResult result = device_dispatch_table(device)->CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateCommandPool(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pCommandPool); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateCommandPool\n"; } + VkResult result = device_dispatch_table(device)->CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyCommandPool", "device, commandPool, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyCommandPool(ApiDumpInstance::current(), device, commandPool, pAllocator); - } + if (ApiDumpInstance::current().shouldDumpOutput()) { + ApiDumpInstance::current().settings().stream() << "vkDestroyCommandPool\n"; } device_dispatch_table(device)->DestroyCommandPool(device, commandPool, pAllocator); ApiDumpInstance::current().eraseCmdBufferPool(device, commandPool); - if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyCommandPool(ApiDumpInstance::current(), device, commandPool, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); - } } template VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkResetCommandPool", "device, commandPool, flags", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkResetCommandPool(ApiDumpInstance::current(), device, commandPool, flags); - } - } - VkResult result = device_dispatch_table(device)->ResetCommandPool(device, commandPool, flags); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkResetCommandPool(ApiDumpInstance::current(), device, commandPool, flags); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkResetCommandPool\n"; } + VkResult result = device_dispatch_table(device)->ResetCommandPool(device, commandPool, flags); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkAllocateCommandBuffers", "device, pAllocateInfo, pCommandBuffers", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkAllocateCommandBuffers(ApiDumpInstance::current(), device, pAllocateInfo, pCommandBuffers); - } + if (ApiDumpInstance::current().shouldDumpOutput()) { + ApiDumpInstance::current().settings().stream() << "vkAllocateCommandBuffers\n"; } VkResult result = device_dispatch_table(device)->AllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers); if (result == VK_SUCCESS) @@ -2961,1964 +1414,934 @@ VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers(VkDevice device, const V pAllocateInfo->commandPool, std::vector(pCommandBuffers, pCommandBuffers + pAllocateInfo->commandBufferCount), pAllocateInfo->level); - if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkAllocateCommandBuffers(ApiDumpInstance::current(), device, pAllocateInfo, pCommandBuffers); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); - } return result; } template VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkFreeCommandBuffers", "device, commandPool, commandBufferCount, pCommandBuffers", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkFreeCommandBuffers(ApiDumpInstance::current(), device, commandPool, commandBufferCount, pCommandBuffers); - } + if (ApiDumpInstance::current().shouldDumpOutput()) { + ApiDumpInstance::current().settings().stream() << "vkFreeCommandBuffers\n"; } device_dispatch_table(device)->FreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers); ApiDumpInstance::current().eraseCmdBuffers(device, commandPool, std::vector(pCommandBuffers, pCommandBuffers + commandBufferCount)); - if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkFreeCommandBuffers(ApiDumpInstance::current(), device, commandPool, commandBufferCount, pCommandBuffers); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); - } } template VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkBeginCommandBuffer", "commandBuffer, pBeginInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkBeginCommandBuffer(ApiDumpInstance::current(), commandBuffer, pBeginInfo); - } - } - VkResult result = device_dispatch_table(commandBuffer)->BeginCommandBuffer(commandBuffer, pBeginInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkBeginCommandBuffer(ApiDumpInstance::current(), commandBuffer, pBeginInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkBeginCommandBuffer\n"; } + VkResult result = device_dispatch_table(commandBuffer)->BeginCommandBuffer(commandBuffer, pBeginInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer(VkCommandBuffer commandBuffer) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkEndCommandBuffer", "commandBuffer", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkEndCommandBuffer(ApiDumpInstance::current(), commandBuffer); - } - } - VkResult result = device_dispatch_table(commandBuffer)->EndCommandBuffer(commandBuffer); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkEndCommandBuffer(ApiDumpInstance::current(), commandBuffer); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkEndCommandBuffer\n"; } + VkResult result = device_dispatch_table(commandBuffer)->EndCommandBuffer(commandBuffer); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkResetCommandBuffer", "commandBuffer, flags", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkResetCommandBuffer(ApiDumpInstance::current(), commandBuffer, flags); - } - } - VkResult result = device_dispatch_table(commandBuffer)->ResetCommandBuffer(commandBuffer, flags); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkResetCommandBuffer(ApiDumpInstance::current(), commandBuffer, flags); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkResetCommandBuffer\n"; } + VkResult result = device_dispatch_table(commandBuffer)->ResetCommandBuffer(commandBuffer, flags); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdCopyBuffer", "commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyBuffer(ApiDumpInstance::current(), commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); - } - } - device_dispatch_table(commandBuffer)->CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyBuffer(ApiDumpInstance::current(), commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdCopyBuffer\n"; } + device_dispatch_table(commandBuffer)->CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdCopyImage", "commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyImage(ApiDumpInstance::current(), commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); - } - } - device_dispatch_table(commandBuffer)->CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyImage(ApiDumpInstance::current(), commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdCopyImage\n"; } + device_dispatch_table(commandBuffer)->CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdCopyBufferToImage", "commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyBufferToImage(ApiDumpInstance::current(), commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions); - } - } - device_dispatch_table(commandBuffer)->CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyBufferToImage(ApiDumpInstance::current(), commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdCopyBufferToImage\n"; } + device_dispatch_table(commandBuffer)->CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions); } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdCopyImageToBuffer", "commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyImageToBuffer(ApiDumpInstance::current(), commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions); - } - } - device_dispatch_table(commandBuffer)->CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyImageToBuffer(ApiDumpInstance::current(), commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdCopyImageToBuffer\n"; } + device_dispatch_table(commandBuffer)->CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions); } template VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdUpdateBuffer", "commandBuffer, dstBuffer, dstOffset, dataSize, pData", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdUpdateBuffer(ApiDumpInstance::current(), commandBuffer, dstBuffer, dstOffset, dataSize, pData); - } - } - device_dispatch_table(commandBuffer)->CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdUpdateBuffer(ApiDumpInstance::current(), commandBuffer, dstBuffer, dstOffset, dataSize, pData); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdUpdateBuffer\n"; } + device_dispatch_table(commandBuffer)->CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData); } template VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdFillBuffer", "commandBuffer, dstBuffer, dstOffset, size, data", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdFillBuffer(ApiDumpInstance::current(), commandBuffer, dstBuffer, dstOffset, size, data); - } - } - device_dispatch_table(commandBuffer)->CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdFillBuffer(ApiDumpInstance::current(), commandBuffer, dstBuffer, dstOffset, size, data); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdFillBuffer\n"; } + device_dispatch_table(commandBuffer)->CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data); } template VKAPI_ATTR void VKAPI_CALL 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) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdPipelineBarrier", "commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdPipelineBarrier(ApiDumpInstance::current(), commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); - } - } - device_dispatch_table(commandBuffer)->CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdPipelineBarrier(ApiDumpInstance::current(), commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdPipelineBarrier\n"; } + device_dispatch_table(commandBuffer)->CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); } template VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBeginQuery", "commandBuffer, queryPool, query, flags", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBeginQuery(ApiDumpInstance::current(), commandBuffer, queryPool, query, flags); - } - } - device_dispatch_table(commandBuffer)->CmdBeginQuery(commandBuffer, queryPool, query, flags); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBeginQuery(ApiDumpInstance::current(), commandBuffer, queryPool, query, flags); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBeginQuery\n"; } + device_dispatch_table(commandBuffer)->CmdBeginQuery(commandBuffer, queryPool, query, flags); } template VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdEndQuery", "commandBuffer, queryPool, query", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdEndQuery(ApiDumpInstance::current(), commandBuffer, queryPool, query); - } - } - device_dispatch_table(commandBuffer)->CmdEndQuery(commandBuffer, queryPool, query); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdEndQuery(ApiDumpInstance::current(), commandBuffer, queryPool, query); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdEndQuery\n"; } + device_dispatch_table(commandBuffer)->CmdEndQuery(commandBuffer, queryPool, query); } template VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdResetQueryPool", "commandBuffer, queryPool, firstQuery, queryCount", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdResetQueryPool(ApiDumpInstance::current(), commandBuffer, queryPool, firstQuery, queryCount); - } - } - device_dispatch_table(commandBuffer)->CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdResetQueryPool(ApiDumpInstance::current(), commandBuffer, queryPool, firstQuery, queryCount); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdResetQueryPool\n"; } + device_dispatch_table(commandBuffer)->CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount); } template VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdWriteTimestamp", "commandBuffer, pipelineStage, queryPool, query", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdWriteTimestamp(ApiDumpInstance::current(), commandBuffer, pipelineStage, queryPool, query); - } - } - device_dispatch_table(commandBuffer)->CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdWriteTimestamp(ApiDumpInstance::current(), commandBuffer, pipelineStage, queryPool, query); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdWriteTimestamp\n"; } + device_dispatch_table(commandBuffer)->CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query); } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdCopyQueryPoolResults", "commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyQueryPoolResults(ApiDumpInstance::current(), commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags); - } - } - device_dispatch_table(commandBuffer)->CmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyQueryPoolResults(ApiDumpInstance::current(), commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdCopyQueryPoolResults\n"; } + device_dispatch_table(commandBuffer)->CmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags); } template VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdExecuteCommands", "commandBuffer, commandBufferCount, pCommandBuffers", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdExecuteCommands(ApiDumpInstance::current(), commandBuffer, commandBufferCount, pCommandBuffers); - } - } - device_dispatch_table(commandBuffer)->CmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdExecuteCommands(ApiDumpInstance::current(), commandBuffer, commandBufferCount, pCommandBuffers); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdExecuteCommands\n"; } + device_dispatch_table(commandBuffer)->CmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateEvent", "device, pCreateInfo, pAllocator, pEvent", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateEvent(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pEvent); - } - } - VkResult result = device_dispatch_table(device)->CreateEvent(device, pCreateInfo, pAllocator, pEvent); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateEvent(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pEvent); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateEvent\n"; } + VkResult result = device_dispatch_table(device)->CreateEvent(device, pCreateInfo, pAllocator, pEvent); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyEvent", "device, event, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyEvent(ApiDumpInstance::current(), device, event, pAllocator); - } - } - device_dispatch_table(device)->DestroyEvent(device, event, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyEvent(ApiDumpInstance::current(), device, event, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyEvent\n"; } + device_dispatch_table(device)->DestroyEvent(device, event, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus(VkDevice device, VkEvent event) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetEventStatus", "device, event", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetEventStatus(ApiDumpInstance::current(), device, event); - } - } - VkResult result = device_dispatch_table(device)->GetEventStatus(device, event); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetEventStatus(ApiDumpInstance::current(), device, event); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetEventStatus\n"; } + VkResult result = device_dispatch_table(device)->GetEventStatus(device, event); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent(VkDevice device, VkEvent event) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkSetEvent", "device, event", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkSetEvent(ApiDumpInstance::current(), device, event); - } - } - VkResult result = device_dispatch_table(device)->SetEvent(device, event); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkSetEvent(ApiDumpInstance::current(), device, event); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkSetEvent\n"; } + VkResult result = device_dispatch_table(device)->SetEvent(device, event); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent(VkDevice device, VkEvent event) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkResetEvent", "device, event", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkResetEvent(ApiDumpInstance::current(), device, event); - } - } - VkResult result = device_dispatch_table(device)->ResetEvent(device, event); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkResetEvent(ApiDumpInstance::current(), device, event); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkResetEvent\n"; } + VkResult result = device_dispatch_table(device)->ResetEvent(device, event); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateBufferView", "device, pCreateInfo, pAllocator, pView", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateBufferView(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pView); - } - } - VkResult result = device_dispatch_table(device)->CreateBufferView(device, pCreateInfo, pAllocator, pView); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateBufferView(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pView); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateBufferView\n"; } + VkResult result = device_dispatch_table(device)->CreateBufferView(device, pCreateInfo, pAllocator, pView); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyBufferView", "device, bufferView, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyBufferView(ApiDumpInstance::current(), device, bufferView, pAllocator); - } - } - device_dispatch_table(device)->DestroyBufferView(device, bufferView, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyBufferView(ApiDumpInstance::current(), device, bufferView, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyBufferView\n"; } + device_dispatch_table(device)->DestroyBufferView(device, bufferView, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateShaderModule", "device, pCreateInfo, pAllocator, pShaderModule", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateShaderModule(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pShaderModule); - } - } - VkResult result = device_dispatch_table(device)->CreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateShaderModule(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pShaderModule); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateShaderModule\n"; } + VkResult result = device_dispatch_table(device)->CreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyShaderModule", "device, shaderModule, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyShaderModule(ApiDumpInstance::current(), device, shaderModule, pAllocator); - } - } - device_dispatch_table(device)->DestroyShaderModule(device, shaderModule, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyShaderModule(ApiDumpInstance::current(), device, shaderModule, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyShaderModule\n"; } + device_dispatch_table(device)->DestroyShaderModule(device, shaderModule, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreatePipelineCache", "device, pCreateInfo, pAllocator, pPipelineCache", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreatePipelineCache(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pPipelineCache); - } - } - VkResult result = device_dispatch_table(device)->CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreatePipelineCache(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pPipelineCache); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreatePipelineCache\n"; } + VkResult result = device_dispatch_table(device)->CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyPipelineCache", "device, pipelineCache, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyPipelineCache(ApiDumpInstance::current(), device, pipelineCache, pAllocator); - } - } - device_dispatch_table(device)->DestroyPipelineCache(device, pipelineCache, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyPipelineCache(ApiDumpInstance::current(), device, pipelineCache, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyPipelineCache\n"; } + device_dispatch_table(device)->DestroyPipelineCache(device, pipelineCache, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPipelineCacheData", "device, pipelineCache, pDataSize, pData", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPipelineCacheData(ApiDumpInstance::current(), device, pipelineCache, pDataSize, pData); - } - } - VkResult result = device_dispatch_table(device)->GetPipelineCacheData(device, pipelineCache, pDataSize, pData); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPipelineCacheData(ApiDumpInstance::current(), device, pipelineCache, pDataSize, pData); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPipelineCacheData\n"; } + VkResult result = device_dispatch_table(device)->GetPipelineCacheData(device, pipelineCache, pDataSize, pData); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkMergePipelineCaches", "device, dstCache, srcCacheCount, pSrcCaches", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkMergePipelineCaches(ApiDumpInstance::current(), device, dstCache, srcCacheCount, pSrcCaches); - } - } - VkResult result = device_dispatch_table(device)->MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkMergePipelineCaches(ApiDumpInstance::current(), device, dstCache, srcCacheCount, pSrcCaches); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkMergePipelineCaches\n"; } + VkResult result = device_dispatch_table(device)->MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateComputePipelines", "device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateComputePipelines(ApiDumpInstance::current(), device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); - } - } - VkResult result = device_dispatch_table(device)->CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateComputePipelines(ApiDumpInstance::current(), device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateComputePipelines\n"; } + VkResult result = device_dispatch_table(device)->CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyPipeline", "device, pipeline, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyPipeline(ApiDumpInstance::current(), device, pipeline, pAllocator); - } - } - device_dispatch_table(device)->DestroyPipeline(device, pipeline, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyPipeline(ApiDumpInstance::current(), device, pipeline, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyPipeline\n"; } + device_dispatch_table(device)->DestroyPipeline(device, pipeline, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreatePipelineLayout", "device, pCreateInfo, pAllocator, pPipelineLayout", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreatePipelineLayout(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pPipelineLayout); - } - } - VkResult result = device_dispatch_table(device)->CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreatePipelineLayout(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pPipelineLayout); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreatePipelineLayout\n"; } + VkResult result = device_dispatch_table(device)->CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyPipelineLayout", "device, pipelineLayout, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyPipelineLayout(ApiDumpInstance::current(), device, pipelineLayout, pAllocator); - } - } - device_dispatch_table(device)->DestroyPipelineLayout(device, pipelineLayout, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyPipelineLayout(ApiDumpInstance::current(), device, pipelineLayout, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyPipelineLayout\n"; } + device_dispatch_table(device)->DestroyPipelineLayout(device, pipelineLayout, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateSampler", "device, pCreateInfo, pAllocator, pSampler", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateSampler(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pSampler); - } - } - VkResult result = device_dispatch_table(device)->CreateSampler(device, pCreateInfo, pAllocator, pSampler); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateSampler(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pSampler); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateSampler\n"; } + VkResult result = device_dispatch_table(device)->CreateSampler(device, pCreateInfo, pAllocator, pSampler); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroySampler", "device, sampler, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroySampler(ApiDumpInstance::current(), device, sampler, pAllocator); - } - } - device_dispatch_table(device)->DestroySampler(device, sampler, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroySampler(ApiDumpInstance::current(), device, sampler, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroySampler\n"; } + device_dispatch_table(device)->DestroySampler(device, sampler, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateDescriptorSetLayout", "device, pCreateInfo, pAllocator, pSetLayout", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateDescriptorSetLayout(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pSetLayout); - } - } - VkResult result = device_dispatch_table(device)->CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateDescriptorSetLayout(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pSetLayout); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateDescriptorSetLayout\n"; } + VkResult result = device_dispatch_table(device)->CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyDescriptorSetLayout", "device, descriptorSetLayout, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyDescriptorSetLayout(ApiDumpInstance::current(), device, descriptorSetLayout, pAllocator); - } - } - device_dispatch_table(device)->DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyDescriptorSetLayout(ApiDumpInstance::current(), device, descriptorSetLayout, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyDescriptorSetLayout\n"; } + device_dispatch_table(device)->DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateDescriptorPool", "device, pCreateInfo, pAllocator, pDescriptorPool", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateDescriptorPool(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pDescriptorPool); - } - } - VkResult result = device_dispatch_table(device)->CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateDescriptorPool(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pDescriptorPool); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateDescriptorPool\n"; } + VkResult result = device_dispatch_table(device)->CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyDescriptorPool", "device, descriptorPool, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyDescriptorPool(ApiDumpInstance::current(), device, descriptorPool, pAllocator); - } - } - device_dispatch_table(device)->DestroyDescriptorPool(device, descriptorPool, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyDescriptorPool(ApiDumpInstance::current(), device, descriptorPool, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyDescriptorPool\n"; } + device_dispatch_table(device)->DestroyDescriptorPool(device, descriptorPool, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkResetDescriptorPool", "device, descriptorPool, flags", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkResetDescriptorPool(ApiDumpInstance::current(), device, descriptorPool, flags); - } - } - VkResult result = device_dispatch_table(device)->ResetDescriptorPool(device, descriptorPool, flags); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkResetDescriptorPool(ApiDumpInstance::current(), device, descriptorPool, flags); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkResetDescriptorPool\n"; } + VkResult result = device_dispatch_table(device)->ResetDescriptorPool(device, descriptorPool, flags); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkAllocateDescriptorSets", "device, pAllocateInfo, pDescriptorSets", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkAllocateDescriptorSets(ApiDumpInstance::current(), device, pAllocateInfo, pDescriptorSets); - } - } - VkResult result = device_dispatch_table(device)->AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkAllocateDescriptorSets(ApiDumpInstance::current(), device, pAllocateInfo, pDescriptorSets); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkAllocateDescriptorSets\n"; } + VkResult result = device_dispatch_table(device)->AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkFreeDescriptorSets", "device, descriptorPool, descriptorSetCount, pDescriptorSets", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkFreeDescriptorSets(ApiDumpInstance::current(), device, descriptorPool, descriptorSetCount, pDescriptorSets); - } - } - VkResult result = device_dispatch_table(device)->FreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkFreeDescriptorSets(ApiDumpInstance::current(), device, descriptorPool, descriptorSetCount, pDescriptorSets); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkFreeDescriptorSets\n"; } + VkResult result = device_dispatch_table(device)->FreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets); return result; } template VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkUpdateDescriptorSets", "device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkUpdateDescriptorSets(ApiDumpInstance::current(), device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); - } - } - device_dispatch_table(device)->UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkUpdateDescriptorSets(ApiDumpInstance::current(), device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkUpdateDescriptorSets\n"; } + device_dispatch_table(device)->UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); } template VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBindPipeline", "commandBuffer, pipelineBindPoint, pipeline", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBindPipeline(ApiDumpInstance::current(), commandBuffer, pipelineBindPoint, pipeline); - } - } - device_dispatch_table(commandBuffer)->CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBindPipeline(ApiDumpInstance::current(), commandBuffer, pipelineBindPoint, pipeline); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBindPipeline\n"; } + device_dispatch_table(commandBuffer)->CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline); } template VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBindDescriptorSets", "commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBindDescriptorSets(ApiDumpInstance::current(), commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); - } - } - device_dispatch_table(commandBuffer)->CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBindDescriptorSets(ApiDumpInstance::current(), commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBindDescriptorSets\n"; } + device_dispatch_table(commandBuffer)->CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); } template VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdClearColorImage", "commandBuffer, image, imageLayout, pColor, rangeCount, pRanges", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdClearColorImage(ApiDumpInstance::current(), commandBuffer, image, imageLayout, pColor, rangeCount, pRanges); - } - } - device_dispatch_table(commandBuffer)->CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdClearColorImage(ApiDumpInstance::current(), commandBuffer, image, imageLayout, pColor, rangeCount, pRanges); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdClearColorImage\n"; } + device_dispatch_table(commandBuffer)->CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges); } template VKAPI_ATTR void VKAPI_CALL vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdDispatch", "commandBuffer, groupCountX, groupCountY, groupCountZ", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDispatch(ApiDumpInstance::current(), commandBuffer, groupCountX, groupCountY, groupCountZ); - } - } - device_dispatch_table(commandBuffer)->CmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDispatch(ApiDumpInstance::current(), commandBuffer, groupCountX, groupCountY, groupCountZ); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdDispatch\n"; } + device_dispatch_table(commandBuffer)->CmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ); } template VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdDispatchIndirect", "commandBuffer, buffer, offset", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDispatchIndirect(ApiDumpInstance::current(), commandBuffer, buffer, offset); - } - } - device_dispatch_table(commandBuffer)->CmdDispatchIndirect(commandBuffer, buffer, offset); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDispatchIndirect(ApiDumpInstance::current(), commandBuffer, buffer, offset); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdDispatchIndirect\n"; } + device_dispatch_table(commandBuffer)->CmdDispatchIndirect(commandBuffer, buffer, offset); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetEvent", "commandBuffer, event, stageMask", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetEvent(ApiDumpInstance::current(), commandBuffer, event, stageMask); - } - } - device_dispatch_table(commandBuffer)->CmdSetEvent(commandBuffer, event, stageMask); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetEvent(ApiDumpInstance::current(), commandBuffer, event, stageMask); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetEvent\n"; } + device_dispatch_table(commandBuffer)->CmdSetEvent(commandBuffer, event, stageMask); } template VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdResetEvent", "commandBuffer, event, stageMask", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdResetEvent(ApiDumpInstance::current(), commandBuffer, event, stageMask); - } - } - device_dispatch_table(commandBuffer)->CmdResetEvent(commandBuffer, event, stageMask); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdResetEvent(ApiDumpInstance::current(), commandBuffer, event, stageMask); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdResetEvent\n"; } + device_dispatch_table(commandBuffer)->CmdResetEvent(commandBuffer, event, stageMask); } template VKAPI_ATTR void VKAPI_CALL 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) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdWaitEvents", "commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdWaitEvents(ApiDumpInstance::current(), commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); - } - } - device_dispatch_table(commandBuffer)->CmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdWaitEvents(ApiDumpInstance::current(), commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdWaitEvents\n"; } + device_dispatch_table(commandBuffer)->CmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); } template VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdPushConstants", "commandBuffer, layout, stageFlags, offset, size, pValues", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdPushConstants(ApiDumpInstance::current(), commandBuffer, layout, stageFlags, offset, size, pValues); - } - } - device_dispatch_table(commandBuffer)->CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdPushConstants(ApiDumpInstance::current(), commandBuffer, layout, stageFlags, offset, size, pValues); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdPushConstants\n"; } + device_dispatch_table(commandBuffer)->CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateGraphicsPipelines", "device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateGraphicsPipelines(ApiDumpInstance::current(), device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); - } - } - VkResult result = device_dispatch_table(device)->CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateGraphicsPipelines(ApiDumpInstance::current(), device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateGraphicsPipelines\n"; } + VkResult result = device_dispatch_table(device)->CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateFramebuffer", "device, pCreateInfo, pAllocator, pFramebuffer", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateFramebuffer(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pFramebuffer); - } - } - VkResult result = device_dispatch_table(device)->CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateFramebuffer(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pFramebuffer); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateFramebuffer\n"; } + VkResult result = device_dispatch_table(device)->CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyFramebuffer", "device, framebuffer, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyFramebuffer(ApiDumpInstance::current(), device, framebuffer, pAllocator); - } - } - device_dispatch_table(device)->DestroyFramebuffer(device, framebuffer, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyFramebuffer(ApiDumpInstance::current(), device, framebuffer, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyFramebuffer\n"; } + device_dispatch_table(device)->DestroyFramebuffer(device, framebuffer, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateRenderPass", "device, pCreateInfo, pAllocator, pRenderPass", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateRenderPass(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pRenderPass); - } - } - VkResult result = device_dispatch_table(device)->CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateRenderPass(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pRenderPass); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateRenderPass\n"; } + VkResult result = device_dispatch_table(device)->CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyRenderPass", "device, renderPass, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyRenderPass(ApiDumpInstance::current(), device, renderPass, pAllocator); - } - } - device_dispatch_table(device)->DestroyRenderPass(device, renderPass, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyRenderPass(ApiDumpInstance::current(), device, renderPass, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyRenderPass\n"; } + device_dispatch_table(device)->DestroyRenderPass(device, renderPass, pAllocator); } template VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetRenderAreaGranularity", "device, renderPass, pGranularity", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetRenderAreaGranularity(ApiDumpInstance::current(), device, renderPass, pGranularity); - } - } - device_dispatch_table(device)->GetRenderAreaGranularity(device, renderPass, pGranularity); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetRenderAreaGranularity(ApiDumpInstance::current(), device, renderPass, pGranularity); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetRenderAreaGranularity\n"; } + device_dispatch_table(device)->GetRenderAreaGranularity(device, renderPass, pGranularity); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetViewport", "commandBuffer, firstViewport, viewportCount, pViewports", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetViewport(ApiDumpInstance::current(), commandBuffer, firstViewport, viewportCount, pViewports); - } - } - device_dispatch_table(commandBuffer)->CmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetViewport(ApiDumpInstance::current(), commandBuffer, firstViewport, viewportCount, pViewports); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetViewport\n"; } + device_dispatch_table(commandBuffer)->CmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetScissor", "commandBuffer, firstScissor, scissorCount, pScissors", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetScissor(ApiDumpInstance::current(), commandBuffer, firstScissor, scissorCount, pScissors); - } - } - device_dispatch_table(commandBuffer)->CmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetScissor(ApiDumpInstance::current(), commandBuffer, firstScissor, scissorCount, pScissors); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetScissor\n"; } + device_dispatch_table(commandBuffer)->CmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetLineWidth", "commandBuffer, lineWidth", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetLineWidth(ApiDumpInstance::current(), commandBuffer, lineWidth); - } - } - device_dispatch_table(commandBuffer)->CmdSetLineWidth(commandBuffer, lineWidth); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetLineWidth(ApiDumpInstance::current(), commandBuffer, lineWidth); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetLineWidth\n"; } + device_dispatch_table(commandBuffer)->CmdSetLineWidth(commandBuffer, lineWidth); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetDepthBias", "commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDepthBias(ApiDumpInstance::current(), commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); - } - } - device_dispatch_table(commandBuffer)->CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDepthBias(ApiDumpInstance::current(), commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetDepthBias\n"; } + device_dispatch_table(commandBuffer)->CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetBlendConstants", "commandBuffer, blendConstants", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetBlendConstants(ApiDumpInstance::current(), commandBuffer, blendConstants); - } - } - device_dispatch_table(commandBuffer)->CmdSetBlendConstants(commandBuffer, blendConstants); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetBlendConstants(ApiDumpInstance::current(), commandBuffer, blendConstants); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetBlendConstants\n"; } + device_dispatch_table(commandBuffer)->CmdSetBlendConstants(commandBuffer, blendConstants); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetDepthBounds", "commandBuffer, minDepthBounds, maxDepthBounds", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDepthBounds(ApiDumpInstance::current(), commandBuffer, minDepthBounds, maxDepthBounds); - } - } - device_dispatch_table(commandBuffer)->CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDepthBounds(ApiDumpInstance::current(), commandBuffer, minDepthBounds, maxDepthBounds); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetDepthBounds\n"; } + device_dispatch_table(commandBuffer)->CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetStencilCompareMask", "commandBuffer, faceMask, compareMask", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetStencilCompareMask(ApiDumpInstance::current(), commandBuffer, faceMask, compareMask); - } - } - device_dispatch_table(commandBuffer)->CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetStencilCompareMask(ApiDumpInstance::current(), commandBuffer, faceMask, compareMask); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetStencilCompareMask\n"; } + device_dispatch_table(commandBuffer)->CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetStencilWriteMask", "commandBuffer, faceMask, writeMask", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetStencilWriteMask(ApiDumpInstance::current(), commandBuffer, faceMask, writeMask); - } - } - device_dispatch_table(commandBuffer)->CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetStencilWriteMask(ApiDumpInstance::current(), commandBuffer, faceMask, writeMask); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetStencilWriteMask\n"; } + device_dispatch_table(commandBuffer)->CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetStencilReference", "commandBuffer, faceMask, reference", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetStencilReference(ApiDumpInstance::current(), commandBuffer, faceMask, reference); - } - } - device_dispatch_table(commandBuffer)->CmdSetStencilReference(commandBuffer, faceMask, reference); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetStencilReference(ApiDumpInstance::current(), commandBuffer, faceMask, reference); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetStencilReference\n"; } + device_dispatch_table(commandBuffer)->CmdSetStencilReference(commandBuffer, faceMask, reference); } template VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBindIndexBuffer", "commandBuffer, buffer, offset, indexType", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBindIndexBuffer(ApiDumpInstance::current(), commandBuffer, buffer, offset, indexType); - } - } - device_dispatch_table(commandBuffer)->CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBindIndexBuffer(ApiDumpInstance::current(), commandBuffer, buffer, offset, indexType); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBindIndexBuffer\n"; } + device_dispatch_table(commandBuffer)->CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType); } template VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBindVertexBuffers", "commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBindVertexBuffers(ApiDumpInstance::current(), commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets); - } - } - device_dispatch_table(commandBuffer)->CmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBindVertexBuffers(ApiDumpInstance::current(), commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBindVertexBuffers\n"; } + device_dispatch_table(commandBuffer)->CmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets); } template VKAPI_ATTR void VKAPI_CALL vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdDraw", "commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDraw(ApiDumpInstance::current(), commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); - } - } - device_dispatch_table(commandBuffer)->CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDraw(ApiDumpInstance::current(), commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdDraw\n"; } + device_dispatch_table(commandBuffer)->CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); } template VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdDrawIndexed", "commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDrawIndexed(ApiDumpInstance::current(), commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); - } - } - device_dispatch_table(commandBuffer)->CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDrawIndexed(ApiDumpInstance::current(), commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdDrawIndexed\n"; } + device_dispatch_table(commandBuffer)->CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); } template VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdDrawIndirect", "commandBuffer, buffer, offset, drawCount, stride", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDrawIndirect(ApiDumpInstance::current(), commandBuffer, buffer, offset, drawCount, stride); - } - } - device_dispatch_table(commandBuffer)->CmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDrawIndirect(ApiDumpInstance::current(), commandBuffer, buffer, offset, drawCount, stride); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdDrawIndirect\n"; } + device_dispatch_table(commandBuffer)->CmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride); } template VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdDrawIndexedIndirect", "commandBuffer, buffer, offset, drawCount, stride", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDrawIndexedIndirect(ApiDumpInstance::current(), commandBuffer, buffer, offset, drawCount, stride); - } - } - device_dispatch_table(commandBuffer)->CmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDrawIndexedIndirect(ApiDumpInstance::current(), commandBuffer, buffer, offset, drawCount, stride); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdDrawIndexedIndirect\n"; } + device_dispatch_table(commandBuffer)->CmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride); } template VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBlitImage", "commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBlitImage(ApiDumpInstance::current(), commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter); - } - } - device_dispatch_table(commandBuffer)->CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBlitImage(ApiDumpInstance::current(), commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBlitImage\n"; } + device_dispatch_table(commandBuffer)->CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter); } template VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdClearDepthStencilImage", "commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdClearDepthStencilImage(ApiDumpInstance::current(), commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges); - } - } - device_dispatch_table(commandBuffer)->CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdClearDepthStencilImage(ApiDumpInstance::current(), commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdClearDepthStencilImage\n"; } + device_dispatch_table(commandBuffer)->CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges); } template VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdClearAttachments", "commandBuffer, attachmentCount, pAttachments, rectCount, pRects", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdClearAttachments(ApiDumpInstance::current(), commandBuffer, attachmentCount, pAttachments, rectCount, pRects); - } - } - device_dispatch_table(commandBuffer)->CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdClearAttachments(ApiDumpInstance::current(), commandBuffer, attachmentCount, pAttachments, rectCount, pRects); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdClearAttachments\n"; } + device_dispatch_table(commandBuffer)->CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects); } template VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdResolveImage", "commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdResolveImage(ApiDumpInstance::current(), commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); - } - } - device_dispatch_table(commandBuffer)->CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdResolveImage(ApiDumpInstance::current(), commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdResolveImage\n"; } + device_dispatch_table(commandBuffer)->CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); } template VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBeginRenderPass", "commandBuffer, pRenderPassBegin, contents", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBeginRenderPass(ApiDumpInstance::current(), commandBuffer, pRenderPassBegin, contents); - } - } - device_dispatch_table(commandBuffer)->CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBeginRenderPass(ApiDumpInstance::current(), commandBuffer, pRenderPassBegin, contents); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBeginRenderPass\n"; } + device_dispatch_table(commandBuffer)->CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents); } template VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdNextSubpass", "commandBuffer, contents", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdNextSubpass(ApiDumpInstance::current(), commandBuffer, contents); - } - } - device_dispatch_table(commandBuffer)->CmdNextSubpass(commandBuffer, contents); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdNextSubpass(ApiDumpInstance::current(), commandBuffer, contents); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdNextSubpass\n"; } + device_dispatch_table(commandBuffer)->CmdNextSubpass(commandBuffer, contents); } template VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass(VkCommandBuffer commandBuffer) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdEndRenderPass", "commandBuffer", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdEndRenderPass(ApiDumpInstance::current(), commandBuffer); - } - } - device_dispatch_table(commandBuffer)->CmdEndRenderPass(commandBuffer); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdEndRenderPass(ApiDumpInstance::current(), commandBuffer); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdEndRenderPass\n"; } + device_dispatch_table(commandBuffer)->CmdEndRenderPass(commandBuffer); } template VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkBindBufferMemory2", "device, bindInfoCount, pBindInfos", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkBindBufferMemory2(ApiDumpInstance::current(), device, bindInfoCount, pBindInfos); - } - } - VkResult result = device_dispatch_table(device)->BindBufferMemory2(device, bindInfoCount, pBindInfos); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkBindBufferMemory2(ApiDumpInstance::current(), device, bindInfoCount, pBindInfos); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkBindBufferMemory2\n"; } + VkResult result = device_dispatch_table(device)->BindBufferMemory2(device, bindInfoCount, pBindInfos); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkBindImageMemory2", "device, bindInfoCount, pBindInfos", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkBindImageMemory2(ApiDumpInstance::current(), device, bindInfoCount, pBindInfos); - } - } - VkResult result = device_dispatch_table(device)->BindImageMemory2(device, bindInfoCount, pBindInfos); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkBindImageMemory2(ApiDumpInstance::current(), device, bindInfoCount, pBindInfos); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkBindImageMemory2\n"; } + VkResult result = device_dispatch_table(device)->BindImageMemory2(device, bindInfoCount, pBindInfos); return result; } template VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDeviceGroupPeerMemoryFeatures", "device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceGroupPeerMemoryFeatures(ApiDumpInstance::current(), device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); - } - } - device_dispatch_table(device)->GetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceGroupPeerMemoryFeatures(ApiDumpInstance::current(), device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDeviceGroupPeerMemoryFeatures\n"; } + device_dispatch_table(device)->GetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetDeviceMask", "commandBuffer, deviceMask", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDeviceMask(ApiDumpInstance::current(), commandBuffer, deviceMask); - } - } - device_dispatch_table(commandBuffer)->CmdSetDeviceMask(commandBuffer, deviceMask); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDeviceMask(ApiDumpInstance::current(), commandBuffer, deviceMask); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetDeviceMask\n"; } + device_dispatch_table(commandBuffer)->CmdSetDeviceMask(commandBuffer, deviceMask); } template VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetImageMemoryRequirements2", "device, pInfo, pMemoryRequirements", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetImageMemoryRequirements2(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements); - } - } - device_dispatch_table(device)->GetImageMemoryRequirements2(device, pInfo, pMemoryRequirements); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetImageMemoryRequirements2(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetImageMemoryRequirements2\n"; } + device_dispatch_table(device)->GetImageMemoryRequirements2(device, pInfo, pMemoryRequirements); } template VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetBufferMemoryRequirements2", "device, pInfo, pMemoryRequirements", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetBufferMemoryRequirements2(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements); - } - } - device_dispatch_table(device)->GetBufferMemoryRequirements2(device, pInfo, pMemoryRequirements); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetBufferMemoryRequirements2(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetBufferMemoryRequirements2\n"; } + device_dispatch_table(device)->GetBufferMemoryRequirements2(device, pInfo, pMemoryRequirements); } template VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetImageSparseMemoryRequirements2", "device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetImageSparseMemoryRequirements2(ApiDumpInstance::current(), device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); - } - } - device_dispatch_table(device)->GetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetImageSparseMemoryRequirements2(ApiDumpInstance::current(), device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetImageSparseMemoryRequirements2\n"; } + device_dispatch_table(device)->GetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); } template VKAPI_ATTR void VKAPI_CALL vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkTrimCommandPool", "device, commandPool, flags", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkTrimCommandPool(ApiDumpInstance::current(), device, commandPool, flags); - } - } - device_dispatch_table(device)->TrimCommandPool(device, commandPool, flags); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkTrimCommandPool(ApiDumpInstance::current(), device, commandPool, flags); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkTrimCommandPool\n"; } + device_dispatch_table(device)->TrimCommandPool(device, commandPool, flags); } template VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDeviceQueue2", "device, pQueueInfo, pQueue", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceQueue2(ApiDumpInstance::current(), device, pQueueInfo, pQueue); - } - } - device_dispatch_table(device)->GetDeviceQueue2(device, pQueueInfo, pQueue); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceQueue2(ApiDumpInstance::current(), device, pQueueInfo, pQueue); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDeviceQueue2\n"; } + device_dispatch_table(device)->GetDeviceQueue2(device, pQueueInfo, pQueue); } template VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdDispatchBase", "commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDispatchBase(ApiDumpInstance::current(), commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); - } - } - device_dispatch_table(commandBuffer)->CmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDispatchBase(ApiDumpInstance::current(), commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdDispatchBase\n"; } + device_dispatch_table(commandBuffer)->CmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateDescriptorUpdateTemplate", "device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateDescriptorUpdateTemplate(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); - } - } - VkResult result = device_dispatch_table(device)->CreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateDescriptorUpdateTemplate(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateDescriptorUpdateTemplate\n"; } + VkResult result = device_dispatch_table(device)->CreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyDescriptorUpdateTemplate", "device, descriptorUpdateTemplate, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyDescriptorUpdateTemplate(ApiDumpInstance::current(), device, descriptorUpdateTemplate, pAllocator); - } - } - device_dispatch_table(device)->DestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyDescriptorUpdateTemplate(ApiDumpInstance::current(), device, descriptorUpdateTemplate, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyDescriptorUpdateTemplate\n"; } + device_dispatch_table(device)->DestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator); } template VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkUpdateDescriptorSetWithTemplate", "device, descriptorSet, descriptorUpdateTemplate, pData", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkUpdateDescriptorSetWithTemplate(ApiDumpInstance::current(), device, descriptorSet, descriptorUpdateTemplate, pData); - } - } - device_dispatch_table(device)->UpdateDescriptorSetWithTemplate(device, descriptorSet, descriptorUpdateTemplate, pData); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkUpdateDescriptorSetWithTemplate(ApiDumpInstance::current(), device, descriptorSet, descriptorUpdateTemplate, pData); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkUpdateDescriptorSetWithTemplate\n"; } + device_dispatch_table(device)->UpdateDescriptorSetWithTemplate(device, descriptorSet, descriptorUpdateTemplate, pData); } template VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDescriptorSetLayoutSupport", "device, pCreateInfo, pSupport", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDescriptorSetLayoutSupport(ApiDumpInstance::current(), device, pCreateInfo, pSupport); - } - } - device_dispatch_table(device)->GetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDescriptorSetLayoutSupport(ApiDumpInstance::current(), device, pCreateInfo, pSupport); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDescriptorSetLayoutSupport\n"; } + device_dispatch_table(device)->GetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateSamplerYcbcrConversion", "device, pCreateInfo, pAllocator, pYcbcrConversion", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateSamplerYcbcrConversion(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pYcbcrConversion); - } - } - VkResult result = device_dispatch_table(device)->CreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateSamplerYcbcrConversion(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pYcbcrConversion); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateSamplerYcbcrConversion\n"; } + VkResult result = device_dispatch_table(device)->CreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroySamplerYcbcrConversion", "device, ycbcrConversion, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroySamplerYcbcrConversion(ApiDumpInstance::current(), device, ycbcrConversion, pAllocator); - } - } - device_dispatch_table(device)->DestroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroySamplerYcbcrConversion(ApiDumpInstance::current(), device, ycbcrConversion, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroySamplerYcbcrConversion\n"; } + device_dispatch_table(device)->DestroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator); } template VKAPI_ATTR void VKAPI_CALL vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkResetQueryPool", "device, queryPool, firstQuery, queryCount", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkResetQueryPool(ApiDumpInstance::current(), device, queryPool, firstQuery, queryCount); - } - } - device_dispatch_table(device)->ResetQueryPool(device, queryPool, firstQuery, queryCount); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkResetQueryPool(ApiDumpInstance::current(), device, queryPool, firstQuery, queryCount); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkResetQueryPool\n"; } + device_dispatch_table(device)->ResetQueryPool(device, queryPool, firstQuery, queryCount); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t* pValue) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetSemaphoreCounterValue", "device, semaphore, pValue", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetSemaphoreCounterValue(ApiDumpInstance::current(), device, semaphore, pValue); - } - } - VkResult result = device_dispatch_table(device)->GetSemaphoreCounterValue(device, semaphore, pValue); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetSemaphoreCounterValue(ApiDumpInstance::current(), device, semaphore, pValue); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetSemaphoreCounterValue\n"; } + VkResult result = device_dispatch_table(device)->GetSemaphoreCounterValue(device, semaphore, pValue); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout) { VkResult result = device_dispatch_table(device)->WaitSemaphores(device, pWaitInfo, timeout); std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkWaitSemaphores", "device, pWaitInfo, timeout", "VkResult"); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkWaitSemaphores(ApiDumpInstance::current(), device, pWaitInfo, timeout); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkWaitSemaphores\n"; } return result; } @@ -4926,1337 +2349,636 @@ template VKAPI_ATTR VkResult VKAPI_CALL vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkSignalSemaphore", "device, pSignalInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkSignalSemaphore(ApiDumpInstance::current(), device, pSignalInfo); - } - } - VkResult result = device_dispatch_table(device)->SignalSemaphore(device, pSignalInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkSignalSemaphore(ApiDumpInstance::current(), device, pSignalInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkSignalSemaphore\n"; } + VkResult result = device_dispatch_table(device)->SignalSemaphore(device, pSignalInfo); return result; } template VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetBufferDeviceAddress", "device, pInfo", "VkDeviceAddress"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetBufferDeviceAddress(ApiDumpInstance::current(), device, pInfo); - } - } - VkDeviceAddress result = device_dispatch_table(device)->GetBufferDeviceAddress(device, pInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkDeviceAddress", result, dump_return_value_VkDeviceAddress); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetBufferDeviceAddress(ApiDumpInstance::current(), device, pInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetBufferDeviceAddress\n"; } + VkDeviceAddress result = device_dispatch_table(device)->GetBufferDeviceAddress(device, pInfo); return result; } template VKAPI_ATTR uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetBufferOpaqueCaptureAddress", "device, pInfo", "uint64_t"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetBufferOpaqueCaptureAddress(ApiDumpInstance::current(), device, pInfo); - } - } - uint64_t result = device_dispatch_table(device)->GetBufferOpaqueCaptureAddress(device, pInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "uint64_t", result); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetBufferOpaqueCaptureAddress(ApiDumpInstance::current(), device, pInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetBufferOpaqueCaptureAddress\n"; } + uint64_t result = device_dispatch_table(device)->GetBufferOpaqueCaptureAddress(device, pInfo); return result; } template VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDeviceMemoryOpaqueCaptureAddress", "device, pInfo", "uint64_t"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceMemoryOpaqueCaptureAddress(ApiDumpInstance::current(), device, pInfo); - } - } - uint64_t result = device_dispatch_table(device)->GetDeviceMemoryOpaqueCaptureAddress(device, pInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "uint64_t", result); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceMemoryOpaqueCaptureAddress(ApiDumpInstance::current(), device, pInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDeviceMemoryOpaqueCaptureAddress\n"; } + uint64_t result = device_dispatch_table(device)->GetDeviceMemoryOpaqueCaptureAddress(device, pInfo); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdDrawIndirectCount", "commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDrawIndirectCount(ApiDumpInstance::current(), commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); - } - } - device_dispatch_table(commandBuffer)->CmdDrawIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDrawIndirectCount(ApiDumpInstance::current(), commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdDrawIndirectCount\n"; } + device_dispatch_table(commandBuffer)->CmdDrawIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); } template VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdDrawIndexedIndirectCount", "commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDrawIndexedIndirectCount(ApiDumpInstance::current(), commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); - } - } - device_dispatch_table(commandBuffer)->CmdDrawIndexedIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDrawIndexedIndirectCount(ApiDumpInstance::current(), commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdDrawIndexedIndirectCount\n"; } + device_dispatch_table(commandBuffer)->CmdDrawIndexedIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateRenderPass2", "device, pCreateInfo, pAllocator, pRenderPass", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateRenderPass2(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pRenderPass); - } - } - VkResult result = device_dispatch_table(device)->CreateRenderPass2(device, pCreateInfo, pAllocator, pRenderPass); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateRenderPass2(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pRenderPass); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateRenderPass2\n"; } + VkResult result = device_dispatch_table(device)->CreateRenderPass2(device, pCreateInfo, pAllocator, pRenderPass); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBeginRenderPass2", "commandBuffer, pRenderPassBegin, pSubpassBeginInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBeginRenderPass2(ApiDumpInstance::current(), commandBuffer, pRenderPassBegin, pSubpassBeginInfo); - } - } - device_dispatch_table(commandBuffer)->CmdBeginRenderPass2(commandBuffer, pRenderPassBegin, pSubpassBeginInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBeginRenderPass2(ApiDumpInstance::current(), commandBuffer, pRenderPassBegin, pSubpassBeginInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBeginRenderPass2\n"; } + device_dispatch_table(commandBuffer)->CmdBeginRenderPass2(commandBuffer, pRenderPassBegin, pSubpassBeginInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass2(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdNextSubpass2", "commandBuffer, pSubpassBeginInfo, pSubpassEndInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdNextSubpass2(ApiDumpInstance::current(), commandBuffer, pSubpassBeginInfo, pSubpassEndInfo); - } - } - device_dispatch_table(commandBuffer)->CmdNextSubpass2(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdNextSubpass2(ApiDumpInstance::current(), commandBuffer, pSubpassBeginInfo, pSubpassEndInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdNextSubpass2\n"; } + device_dispatch_table(commandBuffer)->CmdNextSubpass2(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdEndRenderPass2", "commandBuffer, pSubpassEndInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdEndRenderPass2(ApiDumpInstance::current(), commandBuffer, pSubpassEndInfo); - } - } - device_dispatch_table(commandBuffer)->CmdEndRenderPass2(commandBuffer, pSubpassEndInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdEndRenderPass2(ApiDumpInstance::current(), commandBuffer, pSubpassEndInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdEndRenderPass2\n"; } + device_dispatch_table(commandBuffer)->CmdEndRenderPass2(commandBuffer, pSubpassEndInfo); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreatePrivateDataSlot(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreatePrivateDataSlot", "device, pCreateInfo, pAllocator, pPrivateDataSlot", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreatePrivateDataSlot(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pPrivateDataSlot); - } - } - VkResult result = device_dispatch_table(device)->CreatePrivateDataSlot(device, pCreateInfo, pAllocator, pPrivateDataSlot); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreatePrivateDataSlot(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pPrivateDataSlot); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreatePrivateDataSlot\n"; } + VkResult result = device_dispatch_table(device)->CreatePrivateDataSlot(device, pCreateInfo, pAllocator, pPrivateDataSlot); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyPrivateDataSlot", "device, privateDataSlot, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyPrivateDataSlot(ApiDumpInstance::current(), device, privateDataSlot, pAllocator); - } - } - device_dispatch_table(device)->DestroyPrivateDataSlot(device, privateDataSlot, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyPrivateDataSlot(ApiDumpInstance::current(), device, privateDataSlot, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyPrivateDataSlot\n"; } + device_dispatch_table(device)->DestroyPrivateDataSlot(device, privateDataSlot, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkSetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkSetPrivateData", "device, objectType, objectHandle, privateDataSlot, data", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkSetPrivateData(ApiDumpInstance::current(), device, objectType, objectHandle, privateDataSlot, data); - } - } - VkResult result = device_dispatch_table(device)->SetPrivateData(device, objectType, objectHandle, privateDataSlot, data); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkSetPrivateData(ApiDumpInstance::current(), device, objectType, objectHandle, privateDataSlot, data); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkSetPrivateData\n"; } + VkResult result = device_dispatch_table(device)->SetPrivateData(device, objectType, objectHandle, privateDataSlot, data); return result; } template VKAPI_ATTR void VKAPI_CALL vkGetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPrivateData", "device, objectType, objectHandle, privateDataSlot, pData", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPrivateData(ApiDumpInstance::current(), device, objectType, objectHandle, privateDataSlot, pData); - } - } - device_dispatch_table(device)->GetPrivateData(device, objectType, objectHandle, privateDataSlot, pData); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPrivateData(ApiDumpInstance::current(), device, objectType, objectHandle, privateDataSlot, pData); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPrivateData\n"; } + device_dispatch_table(device)->GetPrivateData(device, objectType, objectHandle, privateDataSlot, pData); } template VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdPipelineBarrier2", "commandBuffer, pDependencyInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdPipelineBarrier2(ApiDumpInstance::current(), commandBuffer, pDependencyInfo); - } - } - device_dispatch_table(commandBuffer)->CmdPipelineBarrier2(commandBuffer, pDependencyInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdPipelineBarrier2(ApiDumpInstance::current(), commandBuffer, pDependencyInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdPipelineBarrier2\n"; } + device_dispatch_table(commandBuffer)->CmdPipelineBarrier2(commandBuffer, pDependencyInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdWriteTimestamp2", "commandBuffer, stage, queryPool, query", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdWriteTimestamp2(ApiDumpInstance::current(), commandBuffer, stage, queryPool, query); - } - } - device_dispatch_table(commandBuffer)->CmdWriteTimestamp2(commandBuffer, stage, queryPool, query); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdWriteTimestamp2(ApiDumpInstance::current(), commandBuffer, stage, queryPool, query); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdWriteTimestamp2\n"; } + device_dispatch_table(commandBuffer)->CmdWriteTimestamp2(commandBuffer, stage, queryPool, query); } template VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkQueueSubmit2", "queue, submitCount, pSubmits, fence", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkQueueSubmit2(ApiDumpInstance::current(), queue, submitCount, pSubmits, fence); - } - } - VkResult result = device_dispatch_table(queue)->QueueSubmit2(queue, submitCount, pSubmits, fence); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkQueueSubmit2(ApiDumpInstance::current(), queue, submitCount, pSubmits, fence); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkQueueSubmit2\n"; } + VkResult result = device_dispatch_table(queue)->QueueSubmit2(queue, submitCount, pSubmits, fence); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer2(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdCopyBuffer2", "commandBuffer, pCopyBufferInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyBuffer2(ApiDumpInstance::current(), commandBuffer, pCopyBufferInfo); - } - } - device_dispatch_table(commandBuffer)->CmdCopyBuffer2(commandBuffer, pCopyBufferInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyBuffer2(ApiDumpInstance::current(), commandBuffer, pCopyBufferInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdCopyBuffer2\n"; } + device_dispatch_table(commandBuffer)->CmdCopyBuffer2(commandBuffer, pCopyBufferInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage2(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdCopyImage2", "commandBuffer, pCopyImageInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyImage2(ApiDumpInstance::current(), commandBuffer, pCopyImageInfo); - } - } - device_dispatch_table(commandBuffer)->CmdCopyImage2(commandBuffer, pCopyImageInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyImage2(ApiDumpInstance::current(), commandBuffer, pCopyImageInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdCopyImage2\n"; } + device_dispatch_table(commandBuffer)->CmdCopyImage2(commandBuffer, pCopyImageInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage2(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdCopyBufferToImage2", "commandBuffer, pCopyBufferToImageInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyBufferToImage2(ApiDumpInstance::current(), commandBuffer, pCopyBufferToImageInfo); - } - } - device_dispatch_table(commandBuffer)->CmdCopyBufferToImage2(commandBuffer, pCopyBufferToImageInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyBufferToImage2(ApiDumpInstance::current(), commandBuffer, pCopyBufferToImageInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdCopyBufferToImage2\n"; } + device_dispatch_table(commandBuffer)->CmdCopyBufferToImage2(commandBuffer, pCopyBufferToImageInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer2(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdCopyImageToBuffer2", "commandBuffer, pCopyImageToBufferInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyImageToBuffer2(ApiDumpInstance::current(), commandBuffer, pCopyImageToBufferInfo); - } - } - device_dispatch_table(commandBuffer)->CmdCopyImageToBuffer2(commandBuffer, pCopyImageToBufferInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyImageToBuffer2(ApiDumpInstance::current(), commandBuffer, pCopyImageToBufferInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdCopyImageToBuffer2\n"; } + device_dispatch_table(commandBuffer)->CmdCopyImageToBuffer2(commandBuffer, pCopyImageToBufferInfo); } template VKAPI_ATTR void VKAPI_CALL vkGetDeviceBufferMemoryRequirements(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDeviceBufferMemoryRequirements", "device, pInfo, pMemoryRequirements", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceBufferMemoryRequirements(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements); - } - } - device_dispatch_table(device)->GetDeviceBufferMemoryRequirements(device, pInfo, pMemoryRequirements); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceBufferMemoryRequirements(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDeviceBufferMemoryRequirements\n"; } + device_dispatch_table(device)->GetDeviceBufferMemoryRequirements(device, pInfo, pMemoryRequirements); } template VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDeviceImageMemoryRequirements", "device, pInfo, pMemoryRequirements", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceImageMemoryRequirements(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements); - } - } - device_dispatch_table(device)->GetDeviceImageMemoryRequirements(device, pInfo, pMemoryRequirements); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceImageMemoryRequirements(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDeviceImageMemoryRequirements\n"; } + device_dispatch_table(device)->GetDeviceImageMemoryRequirements(device, pInfo, pMemoryRequirements); } template VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSparseMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDeviceImageSparseMemoryRequirements", "device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceImageSparseMemoryRequirements(ApiDumpInstance::current(), device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); - } - } - device_dispatch_table(device)->GetDeviceImageSparseMemoryRequirements(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceImageSparseMemoryRequirements(ApiDumpInstance::current(), device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDeviceImageSparseMemoryRequirements\n"; } + device_dispatch_table(device)->GetDeviceImageSparseMemoryRequirements(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetEvent2", "commandBuffer, event, pDependencyInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetEvent2(ApiDumpInstance::current(), commandBuffer, event, pDependencyInfo); - } - } - device_dispatch_table(commandBuffer)->CmdSetEvent2(commandBuffer, event, pDependencyInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetEvent2(ApiDumpInstance::current(), commandBuffer, event, pDependencyInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetEvent2\n"; } + device_dispatch_table(commandBuffer)->CmdSetEvent2(commandBuffer, event, pDependencyInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdResetEvent2", "commandBuffer, event, stageMask", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdResetEvent2(ApiDumpInstance::current(), commandBuffer, event, stageMask); - } - } - device_dispatch_table(commandBuffer)->CmdResetEvent2(commandBuffer, event, stageMask); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdResetEvent2(ApiDumpInstance::current(), commandBuffer, event, stageMask); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdResetEvent2\n"; } + device_dispatch_table(commandBuffer)->CmdResetEvent2(commandBuffer, event, stageMask); } template VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdWaitEvents2", "commandBuffer, eventCount, pEvents, pDependencyInfos", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdWaitEvents2(ApiDumpInstance::current(), commandBuffer, eventCount, pEvents, pDependencyInfos); - } - } - device_dispatch_table(commandBuffer)->CmdWaitEvents2(commandBuffer, eventCount, pEvents, pDependencyInfos); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdWaitEvents2(ApiDumpInstance::current(), commandBuffer, eventCount, pEvents, pDependencyInfos); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdWaitEvents2\n"; } + device_dispatch_table(commandBuffer)->CmdWaitEvents2(commandBuffer, eventCount, pEvents, pDependencyInfos); } template VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage2(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBlitImage2", "commandBuffer, pBlitImageInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBlitImage2(ApiDumpInstance::current(), commandBuffer, pBlitImageInfo); - } - } - device_dispatch_table(commandBuffer)->CmdBlitImage2(commandBuffer, pBlitImageInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBlitImage2(ApiDumpInstance::current(), commandBuffer, pBlitImageInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBlitImage2\n"; } + device_dispatch_table(commandBuffer)->CmdBlitImage2(commandBuffer, pBlitImageInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage2(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdResolveImage2", "commandBuffer, pResolveImageInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdResolveImage2(ApiDumpInstance::current(), commandBuffer, pResolveImageInfo); - } - } - device_dispatch_table(commandBuffer)->CmdResolveImage2(commandBuffer, pResolveImageInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdResolveImage2(ApiDumpInstance::current(), commandBuffer, pResolveImageInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdResolveImage2\n"; } + device_dispatch_table(commandBuffer)->CmdResolveImage2(commandBuffer, pResolveImageInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBeginRendering", "commandBuffer, pRenderingInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBeginRendering(ApiDumpInstance::current(), commandBuffer, pRenderingInfo); - } - } - device_dispatch_table(commandBuffer)->CmdBeginRendering(commandBuffer, pRenderingInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBeginRendering(ApiDumpInstance::current(), commandBuffer, pRenderingInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBeginRendering\n"; } + device_dispatch_table(commandBuffer)->CmdBeginRendering(commandBuffer, pRenderingInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdEndRendering(VkCommandBuffer commandBuffer) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdEndRendering", "commandBuffer", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdEndRendering(ApiDumpInstance::current(), commandBuffer); - } - } - device_dispatch_table(commandBuffer)->CmdEndRendering(commandBuffer); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdEndRendering(ApiDumpInstance::current(), commandBuffer); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdEndRendering\n"; } + device_dispatch_table(commandBuffer)->CmdEndRendering(commandBuffer); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetCullMode", "commandBuffer, cullMode", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetCullMode(ApiDumpInstance::current(), commandBuffer, cullMode); - } - } - device_dispatch_table(commandBuffer)->CmdSetCullMode(commandBuffer, cullMode); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetCullMode(ApiDumpInstance::current(), commandBuffer, cullMode); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetCullMode\n"; } + device_dispatch_table(commandBuffer)->CmdSetCullMode(commandBuffer, cullMode); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetFrontFace", "commandBuffer, frontFace", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetFrontFace(ApiDumpInstance::current(), commandBuffer, frontFace); - } - } - device_dispatch_table(commandBuffer)->CmdSetFrontFace(commandBuffer, frontFace); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetFrontFace(ApiDumpInstance::current(), commandBuffer, frontFace); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetFrontFace\n"; } + device_dispatch_table(commandBuffer)->CmdSetFrontFace(commandBuffer, frontFace); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveTopology(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetPrimitiveTopology", "commandBuffer, primitiveTopology", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetPrimitiveTopology(ApiDumpInstance::current(), commandBuffer, primitiveTopology); - } - } - device_dispatch_table(commandBuffer)->CmdSetPrimitiveTopology(commandBuffer, primitiveTopology); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetPrimitiveTopology(ApiDumpInstance::current(), commandBuffer, primitiveTopology); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetPrimitiveTopology\n"; } + device_dispatch_table(commandBuffer)->CmdSetPrimitiveTopology(commandBuffer, primitiveTopology); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetViewportWithCount", "commandBuffer, viewportCount, pViewports", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetViewportWithCount(ApiDumpInstance::current(), commandBuffer, viewportCount, pViewports); - } - } - device_dispatch_table(commandBuffer)->CmdSetViewportWithCount(commandBuffer, viewportCount, pViewports); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetViewportWithCount(ApiDumpInstance::current(), commandBuffer, viewportCount, pViewports); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetViewportWithCount\n"; } + device_dispatch_table(commandBuffer)->CmdSetViewportWithCount(commandBuffer, viewportCount, pViewports); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetScissorWithCount", "commandBuffer, scissorCount, pScissors", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetScissorWithCount(ApiDumpInstance::current(), commandBuffer, scissorCount, pScissors); - } - } - device_dispatch_table(commandBuffer)->CmdSetScissorWithCount(commandBuffer, scissorCount, pScissors); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetScissorWithCount(ApiDumpInstance::current(), commandBuffer, scissorCount, pScissors); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetScissorWithCount\n"; } + device_dispatch_table(commandBuffer)->CmdSetScissorWithCount(commandBuffer, scissorCount, pScissors); } template VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBindVertexBuffers2", "commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBindVertexBuffers2(ApiDumpInstance::current(), commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides); - } - } - device_dispatch_table(commandBuffer)->CmdBindVertexBuffers2(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBindVertexBuffers2(ApiDumpInstance::current(), commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBindVertexBuffers2\n"; } + device_dispatch_table(commandBuffer)->CmdBindVertexBuffers2(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetDepthTestEnable", "commandBuffer, depthTestEnable", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDepthTestEnable(ApiDumpInstance::current(), commandBuffer, depthTestEnable); - } - } - device_dispatch_table(commandBuffer)->CmdSetDepthTestEnable(commandBuffer, depthTestEnable); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDepthTestEnable(ApiDumpInstance::current(), commandBuffer, depthTestEnable); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetDepthTestEnable\n"; } + device_dispatch_table(commandBuffer)->CmdSetDepthTestEnable(commandBuffer, depthTestEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetDepthWriteEnable", "commandBuffer, depthWriteEnable", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDepthWriteEnable(ApiDumpInstance::current(), commandBuffer, depthWriteEnable); - } - } - device_dispatch_table(commandBuffer)->CmdSetDepthWriteEnable(commandBuffer, depthWriteEnable); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDepthWriteEnable(ApiDumpInstance::current(), commandBuffer, depthWriteEnable); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetDepthWriteEnable\n"; } + device_dispatch_table(commandBuffer)->CmdSetDepthWriteEnable(commandBuffer, depthWriteEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetDepthCompareOp", "commandBuffer, depthCompareOp", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDepthCompareOp(ApiDumpInstance::current(), commandBuffer, depthCompareOp); - } - } - device_dispatch_table(commandBuffer)->CmdSetDepthCompareOp(commandBuffer, depthCompareOp); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDepthCompareOp(ApiDumpInstance::current(), commandBuffer, depthCompareOp); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetDepthCompareOp\n"; } + device_dispatch_table(commandBuffer)->CmdSetDepthCompareOp(commandBuffer, depthCompareOp); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetDepthBoundsTestEnable", "commandBuffer, depthBoundsTestEnable", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDepthBoundsTestEnable(ApiDumpInstance::current(), commandBuffer, depthBoundsTestEnable); - } - } - device_dispatch_table(commandBuffer)->CmdSetDepthBoundsTestEnable(commandBuffer, depthBoundsTestEnable); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDepthBoundsTestEnable(ApiDumpInstance::current(), commandBuffer, depthBoundsTestEnable); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetDepthBoundsTestEnable\n"; } + device_dispatch_table(commandBuffer)->CmdSetDepthBoundsTestEnable(commandBuffer, depthBoundsTestEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilTestEnable(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetStencilTestEnable", "commandBuffer, stencilTestEnable", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetStencilTestEnable(ApiDumpInstance::current(), commandBuffer, stencilTestEnable); - } - } - device_dispatch_table(commandBuffer)->CmdSetStencilTestEnable(commandBuffer, stencilTestEnable); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetStencilTestEnable(ApiDumpInstance::current(), commandBuffer, stencilTestEnable); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetStencilTestEnable\n"; } + device_dispatch_table(commandBuffer)->CmdSetStencilTestEnable(commandBuffer, stencilTestEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetStencilOp", "commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetStencilOp(ApiDumpInstance::current(), commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp); - } - } - device_dispatch_table(commandBuffer)->CmdSetStencilOp(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetStencilOp(ApiDumpInstance::current(), commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetStencilOp\n"; } + device_dispatch_table(commandBuffer)->CmdSetStencilOp(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetRasterizerDiscardEnable", "commandBuffer, rasterizerDiscardEnable", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetRasterizerDiscardEnable(ApiDumpInstance::current(), commandBuffer, rasterizerDiscardEnable); - } - } - device_dispatch_table(commandBuffer)->CmdSetRasterizerDiscardEnable(commandBuffer, rasterizerDiscardEnable); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetRasterizerDiscardEnable(ApiDumpInstance::current(), commandBuffer, rasterizerDiscardEnable); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetRasterizerDiscardEnable\n"; } + device_dispatch_table(commandBuffer)->CmdSetRasterizerDiscardEnable(commandBuffer, rasterizerDiscardEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetDepthBiasEnable", "commandBuffer, depthBiasEnable", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDepthBiasEnable(ApiDumpInstance::current(), commandBuffer, depthBiasEnable); - } - } - device_dispatch_table(commandBuffer)->CmdSetDepthBiasEnable(commandBuffer, depthBiasEnable); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDepthBiasEnable(ApiDumpInstance::current(), commandBuffer, depthBiasEnable); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetDepthBiasEnable\n"; } + device_dispatch_table(commandBuffer)->CmdSetDepthBiasEnable(commandBuffer, depthBiasEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetPrimitiveRestartEnable", "commandBuffer, primitiveRestartEnable", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetPrimitiveRestartEnable(ApiDumpInstance::current(), commandBuffer, primitiveRestartEnable); - } - } - device_dispatch_table(commandBuffer)->CmdSetPrimitiveRestartEnable(commandBuffer, primitiveRestartEnable); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetPrimitiveRestartEnable(ApiDumpInstance::current(), commandBuffer, primitiveRestartEnable); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetPrimitiveRestartEnable\n"; } + device_dispatch_table(commandBuffer)->CmdSetPrimitiveRestartEnable(commandBuffer, primitiveRestartEnable); } template VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory2(VkDevice device, const VkMemoryMapInfo* pMemoryMapInfo, void** ppData) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkMapMemory2", "device, pMemoryMapInfo, ppData", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkMapMemory2(ApiDumpInstance::current(), device, pMemoryMapInfo, ppData); - } - } - VkResult result = device_dispatch_table(device)->MapMemory2(device, pMemoryMapInfo, ppData); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkMapMemory2(ApiDumpInstance::current(), device, pMemoryMapInfo, ppData); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkMapMemory2\n"; } + VkResult result = device_dispatch_table(device)->MapMemory2(device, pMemoryMapInfo, ppData); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkUnmapMemory2(VkDevice device, const VkMemoryUnmapInfo* pMemoryUnmapInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkUnmapMemory2", "device, pMemoryUnmapInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkUnmapMemory2(ApiDumpInstance::current(), device, pMemoryUnmapInfo); - } - } - VkResult result = device_dispatch_table(device)->UnmapMemory2(device, pMemoryUnmapInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkUnmapMemory2(ApiDumpInstance::current(), device, pMemoryUnmapInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkUnmapMemory2\n"; } + VkResult result = device_dispatch_table(device)->UnmapMemory2(device, pMemoryUnmapInfo); return result; } template VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSubresourceLayout(VkDevice device, const VkDeviceImageSubresourceInfo* pInfo, VkSubresourceLayout2* pLayout) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDeviceImageSubresourceLayout", "device, pInfo, pLayout", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceImageSubresourceLayout(ApiDumpInstance::current(), device, pInfo, pLayout); - } - } - device_dispatch_table(device)->GetDeviceImageSubresourceLayout(device, pInfo, pLayout); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceImageSubresourceLayout(ApiDumpInstance::current(), device, pInfo, pLayout); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDeviceImageSubresourceLayout\n"; } + device_dispatch_table(device)->GetDeviceImageSubresourceLayout(device, pInfo, pLayout); } template VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout2(VkDevice device, VkImage image, const VkImageSubresource2* pSubresource, VkSubresourceLayout2* pLayout) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetImageSubresourceLayout2", "device, image, pSubresource, pLayout", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetImageSubresourceLayout2(ApiDumpInstance::current(), device, image, pSubresource, pLayout); - } - } - device_dispatch_table(device)->GetImageSubresourceLayout2(device, image, pSubresource, pLayout); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetImageSubresourceLayout2(ApiDumpInstance::current(), device, image, pSubresource, pLayout); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetImageSubresourceLayout2\n"; } + device_dispatch_table(device)->GetImageSubresourceLayout2(device, image, pSubresource, pLayout); } template VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToImage(VkDevice device, const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCopyMemoryToImage", "device, pCopyMemoryToImageInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCopyMemoryToImage(ApiDumpInstance::current(), device, pCopyMemoryToImageInfo); - } - } - VkResult result = device_dispatch_table(device)->CopyMemoryToImage(device, pCopyMemoryToImageInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCopyMemoryToImage(ApiDumpInstance::current(), device, pCopyMemoryToImageInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCopyMemoryToImage\n"; } + VkResult result = device_dispatch_table(device)->CopyMemoryToImage(device, pCopyMemoryToImageInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCopyImageToMemory(VkDevice device, const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCopyImageToMemory", "device, pCopyImageToMemoryInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCopyImageToMemory(ApiDumpInstance::current(), device, pCopyImageToMemoryInfo); - } - } - VkResult result = device_dispatch_table(device)->CopyImageToMemory(device, pCopyImageToMemoryInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCopyImageToMemory(ApiDumpInstance::current(), device, pCopyImageToMemoryInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCopyImageToMemory\n"; } + VkResult result = device_dispatch_table(device)->CopyImageToMemory(device, pCopyImageToMemoryInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCopyImageToImage(VkDevice device, const VkCopyImageToImageInfo* pCopyImageToImageInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCopyImageToImage", "device, pCopyImageToImageInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCopyImageToImage(ApiDumpInstance::current(), device, pCopyImageToImageInfo); - } - } - VkResult result = device_dispatch_table(device)->CopyImageToImage(device, pCopyImageToImageInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCopyImageToImage(ApiDumpInstance::current(), device, pCopyImageToImageInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCopyImageToImage\n"; } + VkResult result = device_dispatch_table(device)->CopyImageToImage(device, pCopyImageToImageInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkTransitionImageLayout(VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfo* pTransitions) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkTransitionImageLayout", "device, transitionCount, pTransitions", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkTransitionImageLayout(ApiDumpInstance::current(), device, transitionCount, pTransitions); - } - } - VkResult result = device_dispatch_table(device)->TransitionImageLayout(device, transitionCount, pTransitions); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkTransitionImageLayout(ApiDumpInstance::current(), device, transitionCount, pTransitions); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkTransitionImageLayout\n"; } + VkResult result = device_dispatch_table(device)->TransitionImageLayout(device, transitionCount, pTransitions); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSet(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdPushDescriptorSet", "commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdPushDescriptorSet(ApiDumpInstance::current(), commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites); - } - } - device_dispatch_table(commandBuffer)->CmdPushDescriptorSet(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdPushDescriptorSet(ApiDumpInstance::current(), commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdPushDescriptorSet\n"; } + device_dispatch_table(commandBuffer)->CmdPushDescriptorSet(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites); } template VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplate(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdPushDescriptorSetWithTemplate", "commandBuffer, descriptorUpdateTemplate, layout, set, pData", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdPushDescriptorSetWithTemplate(ApiDumpInstance::current(), commandBuffer, descriptorUpdateTemplate, layout, set, pData); - } - } - device_dispatch_table(commandBuffer)->CmdPushDescriptorSetWithTemplate(commandBuffer, descriptorUpdateTemplate, layout, set, pData); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdPushDescriptorSetWithTemplate(ApiDumpInstance::current(), commandBuffer, descriptorUpdateTemplate, layout, set, pData); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdPushDescriptorSetWithTemplate\n"; } + device_dispatch_table(commandBuffer)->CmdPushDescriptorSetWithTemplate(commandBuffer, descriptorUpdateTemplate, layout, set, pData); } template VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets2(VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBindDescriptorSets2", "commandBuffer, pBindDescriptorSetsInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBindDescriptorSets2(ApiDumpInstance::current(), commandBuffer, pBindDescriptorSetsInfo); - } - } - device_dispatch_table(commandBuffer)->CmdBindDescriptorSets2(commandBuffer, pBindDescriptorSetsInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBindDescriptorSets2(ApiDumpInstance::current(), commandBuffer, pBindDescriptorSetsInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBindDescriptorSets2\n"; } + device_dispatch_table(commandBuffer)->CmdBindDescriptorSets2(commandBuffer, pBindDescriptorSetsInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants2(VkCommandBuffer commandBuffer, const VkPushConstantsInfo* pPushConstantsInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdPushConstants2", "commandBuffer, pPushConstantsInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdPushConstants2(ApiDumpInstance::current(), commandBuffer, pPushConstantsInfo); - } - } - device_dispatch_table(commandBuffer)->CmdPushConstants2(commandBuffer, pPushConstantsInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdPushConstants2(ApiDumpInstance::current(), commandBuffer, pPushConstantsInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdPushConstants2\n"; } + device_dispatch_table(commandBuffer)->CmdPushConstants2(commandBuffer, pPushConstantsInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSet2(VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfo* pPushDescriptorSetInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdPushDescriptorSet2", "commandBuffer, pPushDescriptorSetInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdPushDescriptorSet2(ApiDumpInstance::current(), commandBuffer, pPushDescriptorSetInfo); - } - } - device_dispatch_table(commandBuffer)->CmdPushDescriptorSet2(commandBuffer, pPushDescriptorSetInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdPushDescriptorSet2(ApiDumpInstance::current(), commandBuffer, pPushDescriptorSetInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdPushDescriptorSet2\n"; } + device_dispatch_table(commandBuffer)->CmdPushDescriptorSet2(commandBuffer, pPushDescriptorSetInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplate2(VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdPushDescriptorSetWithTemplate2", "commandBuffer, pPushDescriptorSetWithTemplateInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdPushDescriptorSetWithTemplate2(ApiDumpInstance::current(), commandBuffer, pPushDescriptorSetWithTemplateInfo); - } - } - device_dispatch_table(commandBuffer)->CmdPushDescriptorSetWithTemplate2(commandBuffer, pPushDescriptorSetWithTemplateInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdPushDescriptorSetWithTemplate2(ApiDumpInstance::current(), commandBuffer, pPushDescriptorSetWithTemplateInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdPushDescriptorSetWithTemplate2\n"; } + device_dispatch_table(commandBuffer)->CmdPushDescriptorSetWithTemplate2(commandBuffer, pPushDescriptorSetWithTemplateInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStipple(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetLineStipple", "commandBuffer, lineStippleFactor, lineStipplePattern", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetLineStipple(ApiDumpInstance::current(), commandBuffer, lineStippleFactor, lineStipplePattern); - } - } - device_dispatch_table(commandBuffer)->CmdSetLineStipple(commandBuffer, lineStippleFactor, lineStipplePattern); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetLineStipple(ApiDumpInstance::current(), commandBuffer, lineStippleFactor, lineStipplePattern); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetLineStipple\n"; } + device_dispatch_table(commandBuffer)->CmdSetLineStipple(commandBuffer, lineStippleFactor, lineStipplePattern); } template VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer2(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBindIndexBuffer2", "commandBuffer, buffer, offset, size, indexType", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBindIndexBuffer2(ApiDumpInstance::current(), commandBuffer, buffer, offset, size, indexType); - } - } - device_dispatch_table(commandBuffer)->CmdBindIndexBuffer2(commandBuffer, buffer, offset, size, indexType); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBindIndexBuffer2(ApiDumpInstance::current(), commandBuffer, buffer, offset, size, indexType); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBindIndexBuffer2\n"; } + device_dispatch_table(commandBuffer)->CmdBindIndexBuffer2(commandBuffer, buffer, offset, size, indexType); } template VKAPI_ATTR void VKAPI_CALL vkGetRenderingAreaGranularity(VkDevice device, const VkRenderingAreaInfo* pRenderingAreaInfo, VkExtent2D* pGranularity) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetRenderingAreaGranularity", "device, pRenderingAreaInfo, pGranularity", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetRenderingAreaGranularity(ApiDumpInstance::current(), device, pRenderingAreaInfo, pGranularity); - } - } - device_dispatch_table(device)->GetRenderingAreaGranularity(device, pRenderingAreaInfo, pGranularity); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetRenderingAreaGranularity(ApiDumpInstance::current(), device, pRenderingAreaInfo, pGranularity); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetRenderingAreaGranularity\n"; } + device_dispatch_table(device)->GetRenderingAreaGranularity(device, pRenderingAreaInfo, pGranularity); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetRenderingAttachmentLocations(VkCommandBuffer commandBuffer, const VkRenderingAttachmentLocationInfo* pLocationInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetRenderingAttachmentLocations", "commandBuffer, pLocationInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetRenderingAttachmentLocations(ApiDumpInstance::current(), commandBuffer, pLocationInfo); - } - } - device_dispatch_table(commandBuffer)->CmdSetRenderingAttachmentLocations(commandBuffer, pLocationInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetRenderingAttachmentLocations(ApiDumpInstance::current(), commandBuffer, pLocationInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetRenderingAttachmentLocations\n"; } + device_dispatch_table(commandBuffer)->CmdSetRenderingAttachmentLocations(commandBuffer, pLocationInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetRenderingInputAttachmentIndices(VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetRenderingInputAttachmentIndices", "commandBuffer, pInputAttachmentIndexInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetRenderingInputAttachmentIndices(ApiDumpInstance::current(), commandBuffer, pInputAttachmentIndexInfo); - } - } - device_dispatch_table(commandBuffer)->CmdSetRenderingInputAttachmentIndices(commandBuffer, pInputAttachmentIndexInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetRenderingInputAttachmentIndices(ApiDumpInstance::current(), commandBuffer, pInputAttachmentIndexInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetRenderingInputAttachmentIndices\n"; } + device_dispatch_table(commandBuffer)->CmdSetRenderingInputAttachmentIndices(commandBuffer, pInputAttachmentIndexInfo); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateSwapchainKHR", "device, pCreateInfo, pAllocator, pSwapchain", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateSwapchainKHR(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pSwapchain); - } - } - VkResult result = device_dispatch_table(device)->CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateSwapchainKHR(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pSwapchain); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateSwapchainKHR\n"; } + VkResult result = device_dispatch_table(device)->CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroySwapchainKHR", "device, swapchain, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroySwapchainKHR(ApiDumpInstance::current(), device, swapchain, pAllocator); - } - } - device_dispatch_table(device)->DestroySwapchainKHR(device, swapchain, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroySwapchainKHR(ApiDumpInstance::current(), device, swapchain, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroySwapchainKHR\n"; } + device_dispatch_table(device)->DestroySwapchainKHR(device, swapchain, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetSwapchainImagesKHR", "device, swapchain, pSwapchainImageCount, pSwapchainImages", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetSwapchainImagesKHR(ApiDumpInstance::current(), device, swapchain, pSwapchainImageCount, pSwapchainImages); - } - } - VkResult result = device_dispatch_table(device)->GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetSwapchainImagesKHR(ApiDumpInstance::current(), device, swapchain, pSwapchainImageCount, pSwapchainImages); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetSwapchainImagesKHR\n"; } + VkResult result = device_dispatch_table(device)->GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) { VkResult result = device_dispatch_table(device)->AcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex); std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkAcquireNextImageKHR", "device, swapchain, timeout, semaphore, fence, pImageIndex", "VkResult"); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkAcquireNextImageKHR(ApiDumpInstance::current(), device, swapchain, timeout, semaphore, fence, pImageIndex); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkAcquireNextImageKHR\n"; } return result; } @@ -6264,13 +2986,8 @@ template VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo) { VkResult result = device_dispatch_table(queue)->QueuePresentKHR(queue, pPresentInfo); std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkQueuePresentKHR", "queue, pPresentInfo", "VkResult"); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkQueuePresentKHR(ApiDumpInstance::current(), queue, pPresentInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkQueuePresentKHR\n"; } ApiDumpInstance::current().nextFrame(); return result; @@ -6279,460 +2996,219 @@ template VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDeviceGroupPresentCapabilitiesKHR", "device, pDeviceGroupPresentCapabilities", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceGroupPresentCapabilitiesKHR(ApiDumpInstance::current(), device, pDeviceGroupPresentCapabilities); - } - } - VkResult result = device_dispatch_table(device)->GetDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceGroupPresentCapabilitiesKHR(ApiDumpInstance::current(), device, pDeviceGroupPresentCapabilities); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDeviceGroupPresentCapabilitiesKHR\n"; } + VkResult result = device_dispatch_table(device)->GetDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDeviceGroupSurfacePresentModesKHR", "device, surface, pModes", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceGroupSurfacePresentModesKHR(ApiDumpInstance::current(), device, surface, pModes); - } - } - VkResult result = device_dispatch_table(device)->GetDeviceGroupSurfacePresentModesKHR(device, surface, pModes); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceGroupSurfacePresentModesKHR(ApiDumpInstance::current(), device, surface, pModes); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDeviceGroupSurfacePresentModesKHR\n"; } + VkResult result = device_dispatch_table(device)->GetDeviceGroupSurfacePresentModesKHR(device, surface, pModes); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkAcquireNextImage2KHR", "device, pAcquireInfo, pImageIndex", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkAcquireNextImage2KHR(ApiDumpInstance::current(), device, pAcquireInfo, pImageIndex); - } - } - VkResult result = device_dispatch_table(device)->AcquireNextImage2KHR(device, pAcquireInfo, pImageIndex); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkAcquireNextImage2KHR(ApiDumpInstance::current(), device, pAcquireInfo, pImageIndex); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkAcquireNextImage2KHR\n"; } + VkResult result = device_dispatch_table(device)->AcquireNextImage2KHR(device, pAcquireInfo, pImageIndex); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateSharedSwapchainsKHR", "device, swapchainCount, pCreateInfos, pAllocator, pSwapchains", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateSharedSwapchainsKHR(ApiDumpInstance::current(), device, swapchainCount, pCreateInfos, pAllocator, pSwapchains); - } - } - VkResult result = device_dispatch_table(device)->CreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateSharedSwapchainsKHR(ApiDumpInstance::current(), device, swapchainCount, pCreateInfos, pAllocator, pSwapchains); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateSharedSwapchainsKHR\n"; } + VkResult result = device_dispatch_table(device)->CreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateVideoSessionKHR(VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateVideoSessionKHR", "device, pCreateInfo, pAllocator, pVideoSession", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateVideoSessionKHR(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pVideoSession); - } - } - VkResult result = device_dispatch_table(device)->CreateVideoSessionKHR(device, pCreateInfo, pAllocator, pVideoSession); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateVideoSessionKHR(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pVideoSession); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateVideoSessionKHR\n"; } + VkResult result = device_dispatch_table(device)->CreateVideoSessionKHR(device, pCreateInfo, pAllocator, pVideoSession); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyVideoSessionKHR(VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyVideoSessionKHR", "device, videoSession, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyVideoSessionKHR(ApiDumpInstance::current(), device, videoSession, pAllocator); - } - } - device_dispatch_table(device)->DestroyVideoSessionKHR(device, videoSession, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyVideoSessionKHR(ApiDumpInstance::current(), device, videoSession, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyVideoSessionKHR\n"; } + device_dispatch_table(device)->DestroyVideoSessionKHR(device, videoSession, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetVideoSessionMemoryRequirementsKHR(VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetVideoSessionMemoryRequirementsKHR", "device, videoSession, pMemoryRequirementsCount, pMemoryRequirements", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetVideoSessionMemoryRequirementsKHR(ApiDumpInstance::current(), device, videoSession, pMemoryRequirementsCount, pMemoryRequirements); - } - } - VkResult result = device_dispatch_table(device)->GetVideoSessionMemoryRequirementsKHR(device, videoSession, pMemoryRequirementsCount, pMemoryRequirements); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetVideoSessionMemoryRequirementsKHR(ApiDumpInstance::current(), device, videoSession, pMemoryRequirementsCount, pMemoryRequirements); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetVideoSessionMemoryRequirementsKHR\n"; } + VkResult result = device_dispatch_table(device)->GetVideoSessionMemoryRequirementsKHR(device, videoSession, pMemoryRequirementsCount, pMemoryRequirements); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkBindVideoSessionMemoryKHR(VkDevice device, VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkBindVideoSessionMemoryKHR", "device, videoSession, bindSessionMemoryInfoCount, pBindSessionMemoryInfos", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkBindVideoSessionMemoryKHR(ApiDumpInstance::current(), device, videoSession, bindSessionMemoryInfoCount, pBindSessionMemoryInfos); - } - } - VkResult result = device_dispatch_table(device)->BindVideoSessionMemoryKHR(device, videoSession, bindSessionMemoryInfoCount, pBindSessionMemoryInfos); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkBindVideoSessionMemoryKHR(ApiDumpInstance::current(), device, videoSession, bindSessionMemoryInfoCount, pBindSessionMemoryInfos); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkBindVideoSessionMemoryKHR\n"; } + VkResult result = device_dispatch_table(device)->BindVideoSessionMemoryKHR(device, videoSession, bindSessionMemoryInfoCount, pBindSessionMemoryInfos); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateVideoSessionParametersKHR(VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateVideoSessionParametersKHR", "device, pCreateInfo, pAllocator, pVideoSessionParameters", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateVideoSessionParametersKHR(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pVideoSessionParameters); - } - } - VkResult result = device_dispatch_table(device)->CreateVideoSessionParametersKHR(device, pCreateInfo, pAllocator, pVideoSessionParameters); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateVideoSessionParametersKHR(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pVideoSessionParameters); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateVideoSessionParametersKHR\n"; } + VkResult result = device_dispatch_table(device)->CreateVideoSessionParametersKHR(device, pCreateInfo, pAllocator, pVideoSessionParameters); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkUpdateVideoSessionParametersKHR(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkUpdateVideoSessionParametersKHR", "device, videoSessionParameters, pUpdateInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkUpdateVideoSessionParametersKHR(ApiDumpInstance::current(), device, videoSessionParameters, pUpdateInfo); - } - } - VkResult result = device_dispatch_table(device)->UpdateVideoSessionParametersKHR(device, videoSessionParameters, pUpdateInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkUpdateVideoSessionParametersKHR(ApiDumpInstance::current(), device, videoSessionParameters, pUpdateInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkUpdateVideoSessionParametersKHR\n"; } + VkResult result = device_dispatch_table(device)->UpdateVideoSessionParametersKHR(device, videoSessionParameters, pUpdateInfo); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyVideoSessionParametersKHR(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyVideoSessionParametersKHR", "device, videoSessionParameters, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyVideoSessionParametersKHR(ApiDumpInstance::current(), device, videoSessionParameters, pAllocator); - } - } - device_dispatch_table(device)->DestroyVideoSessionParametersKHR(device, videoSessionParameters, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyVideoSessionParametersKHR(ApiDumpInstance::current(), device, videoSessionParameters, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyVideoSessionParametersKHR\n"; } + device_dispatch_table(device)->DestroyVideoSessionParametersKHR(device, videoSessionParameters, pAllocator); } template VKAPI_ATTR void VKAPI_CALL vkCmdBeginVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR* pBeginInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBeginVideoCodingKHR", "commandBuffer, pBeginInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBeginVideoCodingKHR(ApiDumpInstance::current(), commandBuffer, pBeginInfo); - } - } - device_dispatch_table(commandBuffer)->CmdBeginVideoCodingKHR(commandBuffer, pBeginInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBeginVideoCodingKHR(ApiDumpInstance::current(), commandBuffer, pBeginInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBeginVideoCodingKHR\n"; } + device_dispatch_table(commandBuffer)->CmdBeginVideoCodingKHR(commandBuffer, pBeginInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdEndVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR* pEndCodingInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdEndVideoCodingKHR", "commandBuffer, pEndCodingInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdEndVideoCodingKHR(ApiDumpInstance::current(), commandBuffer, pEndCodingInfo); - } - } - device_dispatch_table(commandBuffer)->CmdEndVideoCodingKHR(commandBuffer, pEndCodingInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdEndVideoCodingKHR(ApiDumpInstance::current(), commandBuffer, pEndCodingInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdEndVideoCodingKHR\n"; } + device_dispatch_table(commandBuffer)->CmdEndVideoCodingKHR(commandBuffer, pEndCodingInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdControlVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdControlVideoCodingKHR", "commandBuffer, pCodingControlInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdControlVideoCodingKHR(ApiDumpInstance::current(), commandBuffer, pCodingControlInfo); - } - } - device_dispatch_table(commandBuffer)->CmdControlVideoCodingKHR(commandBuffer, pCodingControlInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdControlVideoCodingKHR(ApiDumpInstance::current(), commandBuffer, pCodingControlInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdControlVideoCodingKHR\n"; } + device_dispatch_table(commandBuffer)->CmdControlVideoCodingKHR(commandBuffer, pCodingControlInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdDecodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pDecodeInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdDecodeVideoKHR", "commandBuffer, pDecodeInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDecodeVideoKHR(ApiDumpInstance::current(), commandBuffer, pDecodeInfo); - } - } - device_dispatch_table(commandBuffer)->CmdDecodeVideoKHR(commandBuffer, pDecodeInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDecodeVideoKHR(ApiDumpInstance::current(), commandBuffer, pDecodeInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdDecodeVideoKHR\n"; } + device_dispatch_table(commandBuffer)->CmdDecodeVideoKHR(commandBuffer, pDecodeInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderingKHR(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBeginRenderingKHR", "commandBuffer, pRenderingInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBeginRenderingKHR(ApiDumpInstance::current(), commandBuffer, pRenderingInfo); - } - } - device_dispatch_table(commandBuffer)->CmdBeginRenderingKHR(commandBuffer, pRenderingInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBeginRenderingKHR(ApiDumpInstance::current(), commandBuffer, pRenderingInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBeginRenderingKHR\n"; } + device_dispatch_table(commandBuffer)->CmdBeginRenderingKHR(commandBuffer, pRenderingInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderingKHR(VkCommandBuffer commandBuffer) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdEndRenderingKHR", "commandBuffer", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdEndRenderingKHR(ApiDumpInstance::current(), commandBuffer); - } - } - device_dispatch_table(commandBuffer)->CmdEndRenderingKHR(commandBuffer); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdEndRenderingKHR(ApiDumpInstance::current(), commandBuffer); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdEndRenderingKHR\n"; } + device_dispatch_table(commandBuffer)->CmdEndRenderingKHR(commandBuffer); } template VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDeviceGroupPeerMemoryFeaturesKHR", "device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceGroupPeerMemoryFeaturesKHR(ApiDumpInstance::current(), device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); - } - } - device_dispatch_table(device)->GetDeviceGroupPeerMemoryFeaturesKHR(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceGroupPeerMemoryFeaturesKHR(ApiDumpInstance::current(), device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDeviceGroupPeerMemoryFeaturesKHR\n"; } + device_dispatch_table(device)->GetDeviceGroupPeerMemoryFeaturesKHR(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetDeviceMaskKHR", "commandBuffer, deviceMask", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDeviceMaskKHR(ApiDumpInstance::current(), commandBuffer, deviceMask); - } - } - device_dispatch_table(commandBuffer)->CmdSetDeviceMaskKHR(commandBuffer, deviceMask); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDeviceMaskKHR(ApiDumpInstance::current(), commandBuffer, deviceMask); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetDeviceMaskKHR\n"; } + device_dispatch_table(commandBuffer)->CmdSetDeviceMaskKHR(commandBuffer, deviceMask); } template VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdDispatchBaseKHR", "commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDispatchBaseKHR(ApiDumpInstance::current(), commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); - } - } - device_dispatch_table(commandBuffer)->CmdDispatchBaseKHR(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDispatchBaseKHR(ApiDumpInstance::current(), commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdDispatchBaseKHR\n"; } + device_dispatch_table(commandBuffer)->CmdDispatchBaseKHR(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); } template VKAPI_ATTR void VKAPI_CALL vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkTrimCommandPoolKHR", "device, commandPool, flags", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkTrimCommandPoolKHR(ApiDumpInstance::current(), device, commandPool, flags); - } - } - device_dispatch_table(device)->TrimCommandPoolKHR(device, commandPool, flags); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkTrimCommandPoolKHR(ApiDumpInstance::current(), device, commandPool, flags); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkTrimCommandPoolKHR\n"; } + device_dispatch_table(device)->TrimCommandPoolKHR(device, commandPool, flags); } #if defined(VK_USE_PLATFORM_WIN32_KHR) template VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR(VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetMemoryWin32HandleKHR", "device, pGetWin32HandleInfo, pHandle", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetMemoryWin32HandleKHR(ApiDumpInstance::current(), device, pGetWin32HandleInfo, pHandle); - } - } - VkResult result = device_dispatch_table(device)->GetMemoryWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetMemoryWin32HandleKHR(ApiDumpInstance::current(), device, pGetWin32HandleInfo, pHandle); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetMemoryWin32HandleKHR\n"; } + VkResult result = device_dispatch_table(device)->GetMemoryWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetMemoryWin32HandlePropertiesKHR", "device, handleType, handle, pMemoryWin32HandleProperties", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetMemoryWin32HandlePropertiesKHR(ApiDumpInstance::current(), device, handleType, handle, pMemoryWin32HandleProperties); - } - } - VkResult result = device_dispatch_table(device)->GetMemoryWin32HandlePropertiesKHR(device, handleType, handle, pMemoryWin32HandleProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetMemoryWin32HandlePropertiesKHR(ApiDumpInstance::current(), device, handleType, handle, pMemoryWin32HandleProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetMemoryWin32HandlePropertiesKHR\n"; } + VkResult result = device_dispatch_table(device)->GetMemoryWin32HandlePropertiesKHR(device, handleType, handle, pMemoryWin32HandleProperties); return result; } #endif // VK_USE_PLATFORM_WIN32_KHR @@ -6740,42 +3216,20 @@ template VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdKHR(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetMemoryFdKHR", "device, pGetFdInfo, pFd", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetMemoryFdKHR(ApiDumpInstance::current(), device, pGetFdInfo, pFd); - } - } - VkResult result = device_dispatch_table(device)->GetMemoryFdKHR(device, pGetFdInfo, pFd); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetMemoryFdKHR(ApiDumpInstance::current(), device, pGetFdInfo, pFd); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetMemoryFdKHR\n"; } + VkResult result = device_dispatch_table(device)->GetMemoryFdKHR(device, pGetFdInfo, pFd); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetMemoryFdPropertiesKHR", "device, handleType, fd, pMemoryFdProperties", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetMemoryFdPropertiesKHR(ApiDumpInstance::current(), device, handleType, fd, pMemoryFdProperties); - } - } - VkResult result = device_dispatch_table(device)->GetMemoryFdPropertiesKHR(device, handleType, fd, pMemoryFdProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetMemoryFdPropertiesKHR(ApiDumpInstance::current(), device, handleType, fd, pMemoryFdProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetMemoryFdPropertiesKHR\n"; } + VkResult result = device_dispatch_table(device)->GetMemoryFdPropertiesKHR(device, handleType, fd, pMemoryFdProperties); return result; } #if defined(VK_USE_PLATFORM_WIN32_KHR) @@ -6783,42 +3237,20 @@ template VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHR(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkImportSemaphoreWin32HandleKHR", "device, pImportSemaphoreWin32HandleInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkImportSemaphoreWin32HandleKHR(ApiDumpInstance::current(), device, pImportSemaphoreWin32HandleInfo); - } - } - VkResult result = device_dispatch_table(device)->ImportSemaphoreWin32HandleKHR(device, pImportSemaphoreWin32HandleInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkImportSemaphoreWin32HandleKHR(ApiDumpInstance::current(), device, pImportSemaphoreWin32HandleInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkImportSemaphoreWin32HandleKHR\n"; } + VkResult result = device_dispatch_table(device)->ImportSemaphoreWin32HandleKHR(device, pImportSemaphoreWin32HandleInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHR(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetSemaphoreWin32HandleKHR", "device, pGetWin32HandleInfo, pHandle", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetSemaphoreWin32HandleKHR(ApiDumpInstance::current(), device, pGetWin32HandleInfo, pHandle); - } - } - VkResult result = device_dispatch_table(device)->GetSemaphoreWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetSemaphoreWin32HandleKHR(ApiDumpInstance::current(), device, pGetWin32HandleInfo, pHandle); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetSemaphoreWin32HandleKHR\n"; } + VkResult result = device_dispatch_table(device)->GetSemaphoreWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); return result; } #endif // VK_USE_PLATFORM_WIN32_KHR @@ -6826,238 +3258,113 @@ template VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreFdKHR(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkImportSemaphoreFdKHR", "device, pImportSemaphoreFdInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkImportSemaphoreFdKHR(ApiDumpInstance::current(), device, pImportSemaphoreFdInfo); - } - } - VkResult result = device_dispatch_table(device)->ImportSemaphoreFdKHR(device, pImportSemaphoreFdInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkImportSemaphoreFdKHR(ApiDumpInstance::current(), device, pImportSemaphoreFdInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkImportSemaphoreFdKHR\n"; } + VkResult result = device_dispatch_table(device)->ImportSemaphoreFdKHR(device, pImportSemaphoreFdInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetSemaphoreFdKHR", "device, pGetFdInfo, pFd", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetSemaphoreFdKHR(ApiDumpInstance::current(), device, pGetFdInfo, pFd); - } - } - VkResult result = device_dispatch_table(device)->GetSemaphoreFdKHR(device, pGetFdInfo, pFd); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetSemaphoreFdKHR(ApiDumpInstance::current(), device, pGetFdInfo, pFd); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetSemaphoreFdKHR\n"; } + VkResult result = device_dispatch_table(device)->GetSemaphoreFdKHR(device, pGetFdInfo, pFd); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdPushDescriptorSetKHR", "commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdPushDescriptorSetKHR(ApiDumpInstance::current(), commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites); - } - } - device_dispatch_table(commandBuffer)->CmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdPushDescriptorSetKHR(ApiDumpInstance::current(), commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdPushDescriptorSetKHR\n"; } + device_dispatch_table(commandBuffer)->CmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites); } template VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdPushDescriptorSetWithTemplateKHR", "commandBuffer, descriptorUpdateTemplate, layout, set, pData", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdPushDescriptorSetWithTemplateKHR(ApiDumpInstance::current(), commandBuffer, descriptorUpdateTemplate, layout, set, pData); - } - } - device_dispatch_table(commandBuffer)->CmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdPushDescriptorSetWithTemplateKHR(ApiDumpInstance::current(), commandBuffer, descriptorUpdateTemplate, layout, set, pData); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdPushDescriptorSetWithTemplateKHR\n"; } + device_dispatch_table(commandBuffer)->CmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplateKHR(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateDescriptorUpdateTemplateKHR", "device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateDescriptorUpdateTemplateKHR(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); - } - } - VkResult result = device_dispatch_table(device)->CreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateDescriptorUpdateTemplateKHR(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateDescriptorUpdateTemplateKHR\n"; } + VkResult result = device_dispatch_table(device)->CreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplateKHR(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyDescriptorUpdateTemplateKHR", "device, descriptorUpdateTemplate, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyDescriptorUpdateTemplateKHR(ApiDumpInstance::current(), device, descriptorUpdateTemplate, pAllocator); - } - } - device_dispatch_table(device)->DestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyDescriptorUpdateTemplateKHR(ApiDumpInstance::current(), device, descriptorUpdateTemplate, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyDescriptorUpdateTemplateKHR\n"; } + device_dispatch_table(device)->DestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator); } template VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkUpdateDescriptorSetWithTemplateKHR", "device, descriptorSet, descriptorUpdateTemplate, pData", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkUpdateDescriptorSetWithTemplateKHR(ApiDumpInstance::current(), device, descriptorSet, descriptorUpdateTemplate, pData); - } - } - device_dispatch_table(device)->UpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate, pData); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkUpdateDescriptorSetWithTemplateKHR(ApiDumpInstance::current(), device, descriptorSet, descriptorUpdateTemplate, pData); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkUpdateDescriptorSetWithTemplateKHR\n"; } + device_dispatch_table(device)->UpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate, pData); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateRenderPass2KHR", "device, pCreateInfo, pAllocator, pRenderPass", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateRenderPass2KHR(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pRenderPass); - } - } - VkResult result = device_dispatch_table(device)->CreateRenderPass2KHR(device, pCreateInfo, pAllocator, pRenderPass); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateRenderPass2KHR(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pRenderPass); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateRenderPass2KHR\n"; } + VkResult result = device_dispatch_table(device)->CreateRenderPass2KHR(device, pCreateInfo, pAllocator, pRenderPass); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBeginRenderPass2KHR", "commandBuffer, pRenderPassBegin, pSubpassBeginInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBeginRenderPass2KHR(ApiDumpInstance::current(), commandBuffer, pRenderPassBegin, pSubpassBeginInfo); - } - } - device_dispatch_table(commandBuffer)->CmdBeginRenderPass2KHR(commandBuffer, pRenderPassBegin, pSubpassBeginInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBeginRenderPass2KHR(ApiDumpInstance::current(), commandBuffer, pRenderPassBegin, pSubpassBeginInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBeginRenderPass2KHR\n"; } + device_dispatch_table(commandBuffer)->CmdBeginRenderPass2KHR(commandBuffer, pRenderPassBegin, pSubpassBeginInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdNextSubpass2KHR", "commandBuffer, pSubpassBeginInfo, pSubpassEndInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdNextSubpass2KHR(ApiDumpInstance::current(), commandBuffer, pSubpassBeginInfo, pSubpassEndInfo); - } - } - device_dispatch_table(commandBuffer)->CmdNextSubpass2KHR(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdNextSubpass2KHR(ApiDumpInstance::current(), commandBuffer, pSubpassBeginInfo, pSubpassEndInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdNextSubpass2KHR\n"; } + device_dispatch_table(commandBuffer)->CmdNextSubpass2KHR(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdEndRenderPass2KHR", "commandBuffer, pSubpassEndInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdEndRenderPass2KHR(ApiDumpInstance::current(), commandBuffer, pSubpassEndInfo); - } - } - device_dispatch_table(commandBuffer)->CmdEndRenderPass2KHR(commandBuffer, pSubpassEndInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdEndRenderPass2KHR(ApiDumpInstance::current(), commandBuffer, pSubpassEndInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdEndRenderPass2KHR\n"; } + device_dispatch_table(commandBuffer)->CmdEndRenderPass2KHR(commandBuffer, pSubpassEndInfo); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetSwapchainStatusKHR", "device, swapchain", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetSwapchainStatusKHR(ApiDumpInstance::current(), device, swapchain); - } - } - VkResult result = device_dispatch_table(device)->GetSwapchainStatusKHR(device, swapchain); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetSwapchainStatusKHR(ApiDumpInstance::current(), device, swapchain); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetSwapchainStatusKHR\n"; } + VkResult result = device_dispatch_table(device)->GetSwapchainStatusKHR(device, swapchain); return result; } #if defined(VK_USE_PLATFORM_WIN32_KHR) @@ -7065,42 +3372,20 @@ template VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceWin32HandleKHR(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkImportFenceWin32HandleKHR", "device, pImportFenceWin32HandleInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkImportFenceWin32HandleKHR(ApiDumpInstance::current(), device, pImportFenceWin32HandleInfo); - } - } - VkResult result = device_dispatch_table(device)->ImportFenceWin32HandleKHR(device, pImportFenceWin32HandleInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkImportFenceWin32HandleKHR(ApiDumpInstance::current(), device, pImportFenceWin32HandleInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkImportFenceWin32HandleKHR\n"; } + VkResult result = device_dispatch_table(device)->ImportFenceWin32HandleKHR(device, pImportFenceWin32HandleInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetFenceWin32HandleKHR", "device, pGetWin32HandleInfo, pHandle", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetFenceWin32HandleKHR(ApiDumpInstance::current(), device, pGetWin32HandleInfo, pHandle); - } - } - VkResult result = device_dispatch_table(device)->GetFenceWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetFenceWin32HandleKHR(ApiDumpInstance::current(), device, pGetWin32HandleInfo, pHandle); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetFenceWin32HandleKHR\n"; } + VkResult result = device_dispatch_table(device)->GetFenceWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); return result; } #endif // VK_USE_PLATFORM_WIN32_KHR @@ -7108,312 +3393,150 @@ template VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceFdKHR(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkImportFenceFdKHR", "device, pImportFenceFdInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkImportFenceFdKHR(ApiDumpInstance::current(), device, pImportFenceFdInfo); - } - } - VkResult result = device_dispatch_table(device)->ImportFenceFdKHR(device, pImportFenceFdInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkImportFenceFdKHR(ApiDumpInstance::current(), device, pImportFenceFdInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkImportFenceFdKHR\n"; } + VkResult result = device_dispatch_table(device)->ImportFenceFdKHR(device, pImportFenceFdInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetFenceFdKHR", "device, pGetFdInfo, pFd", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetFenceFdKHR(ApiDumpInstance::current(), device, pGetFdInfo, pFd); - } - } - VkResult result = device_dispatch_table(device)->GetFenceFdKHR(device, pGetFdInfo, pFd); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetFenceFdKHR(ApiDumpInstance::current(), device, pGetFdInfo, pFd); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetFenceFdKHR\n"; } + VkResult result = device_dispatch_table(device)->GetFenceFdKHR(device, pGetFdInfo, pFd); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkAcquireProfilingLockKHR(VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkAcquireProfilingLockKHR", "device, pInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkAcquireProfilingLockKHR(ApiDumpInstance::current(), device, pInfo); - } - } - VkResult result = device_dispatch_table(device)->AcquireProfilingLockKHR(device, pInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkAcquireProfilingLockKHR(ApiDumpInstance::current(), device, pInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkAcquireProfilingLockKHR\n"; } + VkResult result = device_dispatch_table(device)->AcquireProfilingLockKHR(device, pInfo); return result; } template VKAPI_ATTR void VKAPI_CALL vkReleaseProfilingLockKHR(VkDevice device) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkReleaseProfilingLockKHR", "device", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkReleaseProfilingLockKHR(ApiDumpInstance::current(), device); - } - } - device_dispatch_table(device)->ReleaseProfilingLockKHR(device); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkReleaseProfilingLockKHR(ApiDumpInstance::current(), device); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkReleaseProfilingLockKHR\n"; } + device_dispatch_table(device)->ReleaseProfilingLockKHR(device); } template VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetImageMemoryRequirements2KHR", "device, pInfo, pMemoryRequirements", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetImageMemoryRequirements2KHR(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements); - } - } - device_dispatch_table(device)->GetImageMemoryRequirements2KHR(device, pInfo, pMemoryRequirements); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetImageMemoryRequirements2KHR(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetImageMemoryRequirements2KHR\n"; } + device_dispatch_table(device)->GetImageMemoryRequirements2KHR(device, pInfo, pMemoryRequirements); } template VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetBufferMemoryRequirements2KHR", "device, pInfo, pMemoryRequirements", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetBufferMemoryRequirements2KHR(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements); - } - } - device_dispatch_table(device)->GetBufferMemoryRequirements2KHR(device, pInfo, pMemoryRequirements); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetBufferMemoryRequirements2KHR(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetBufferMemoryRequirements2KHR\n"; } + device_dispatch_table(device)->GetBufferMemoryRequirements2KHR(device, pInfo, pMemoryRequirements); } template VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2KHR(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetImageSparseMemoryRequirements2KHR", "device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetImageSparseMemoryRequirements2KHR(ApiDumpInstance::current(), device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); - } - } - device_dispatch_table(device)->GetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetImageSparseMemoryRequirements2KHR(ApiDumpInstance::current(), device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetImageSparseMemoryRequirements2KHR\n"; } + device_dispatch_table(device)->GetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversionKHR(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateSamplerYcbcrConversionKHR", "device, pCreateInfo, pAllocator, pYcbcrConversion", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateSamplerYcbcrConversionKHR(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pYcbcrConversion); - } - } - VkResult result = device_dispatch_table(device)->CreateSamplerYcbcrConversionKHR(device, pCreateInfo, pAllocator, pYcbcrConversion); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateSamplerYcbcrConversionKHR(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pYcbcrConversion); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateSamplerYcbcrConversionKHR\n"; } + VkResult result = device_dispatch_table(device)->CreateSamplerYcbcrConversionKHR(device, pCreateInfo, pAllocator, pYcbcrConversion); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroySamplerYcbcrConversionKHR", "device, ycbcrConversion, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroySamplerYcbcrConversionKHR(ApiDumpInstance::current(), device, ycbcrConversion, pAllocator); - } - } - device_dispatch_table(device)->DestroySamplerYcbcrConversionKHR(device, ycbcrConversion, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroySamplerYcbcrConversionKHR(ApiDumpInstance::current(), device, ycbcrConversion, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroySamplerYcbcrConversionKHR\n"; } + device_dispatch_table(device)->DestroySamplerYcbcrConversionKHR(device, ycbcrConversion, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkBindBufferMemory2KHR", "device, bindInfoCount, pBindInfos", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkBindBufferMemory2KHR(ApiDumpInstance::current(), device, bindInfoCount, pBindInfos); - } - } - VkResult result = device_dispatch_table(device)->BindBufferMemory2KHR(device, bindInfoCount, pBindInfos); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkBindBufferMemory2KHR(ApiDumpInstance::current(), device, bindInfoCount, pBindInfos); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkBindBufferMemory2KHR\n"; } + VkResult result = device_dispatch_table(device)->BindBufferMemory2KHR(device, bindInfoCount, pBindInfos); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkBindImageMemory2KHR", "device, bindInfoCount, pBindInfos", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkBindImageMemory2KHR(ApiDumpInstance::current(), device, bindInfoCount, pBindInfos); - } - } - VkResult result = device_dispatch_table(device)->BindImageMemory2KHR(device, bindInfoCount, pBindInfos); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkBindImageMemory2KHR(ApiDumpInstance::current(), device, bindInfoCount, pBindInfos); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkBindImageMemory2KHR\n"; } + VkResult result = device_dispatch_table(device)->BindImageMemory2KHR(device, bindInfoCount, pBindInfos); return result; } template VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupportKHR(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDescriptorSetLayoutSupportKHR", "device, pCreateInfo, pSupport", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDescriptorSetLayoutSupportKHR(ApiDumpInstance::current(), device, pCreateInfo, pSupport); - } - } - device_dispatch_table(device)->GetDescriptorSetLayoutSupportKHR(device, pCreateInfo, pSupport); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDescriptorSetLayoutSupportKHR(ApiDumpInstance::current(), device, pCreateInfo, pSupport); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDescriptorSetLayoutSupportKHR\n"; } + device_dispatch_table(device)->GetDescriptorSetLayoutSupportKHR(device, pCreateInfo, pSupport); } template VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdDrawIndirectCountKHR", "commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDrawIndirectCountKHR(ApiDumpInstance::current(), commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); - } - } - device_dispatch_table(commandBuffer)->CmdDrawIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDrawIndirectCountKHR(ApiDumpInstance::current(), commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdDrawIndirectCountKHR\n"; } + device_dispatch_table(commandBuffer)->CmdDrawIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); } template VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdDrawIndexedIndirectCountKHR", "commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDrawIndexedIndirectCountKHR(ApiDumpInstance::current(), commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); - } - } - device_dispatch_table(commandBuffer)->CmdDrawIndexedIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDrawIndexedIndirectCountKHR(ApiDumpInstance::current(), commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdDrawIndexedIndirectCountKHR\n"; } + device_dispatch_table(commandBuffer)->CmdDrawIndexedIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore, uint64_t* pValue) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetSemaphoreCounterValueKHR", "device, semaphore, pValue", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetSemaphoreCounterValueKHR(ApiDumpInstance::current(), device, semaphore, pValue); - } - } - VkResult result = device_dispatch_table(device)->GetSemaphoreCounterValueKHR(device, semaphore, pValue); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetSemaphoreCounterValueKHR(ApiDumpInstance::current(), device, semaphore, pValue); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetSemaphoreCounterValueKHR\n"; } + VkResult result = device_dispatch_table(device)->GetSemaphoreCounterValueKHR(device, semaphore, pValue); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkWaitSemaphoresKHR(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout) { VkResult result = device_dispatch_table(device)->WaitSemaphoresKHR(device, pWaitInfo, timeout); std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkWaitSemaphoresKHR", "device, pWaitInfo, timeout", "VkResult"); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkWaitSemaphoresKHR(ApiDumpInstance::current(), device, pWaitInfo, timeout); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkWaitSemaphoresKHR\n"; } return result; } @@ -7421,1169 +3544,555 @@ template VKAPI_ATTR VkResult VKAPI_CALL vkSignalSemaphoreKHR(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkSignalSemaphoreKHR", "device, pSignalInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkSignalSemaphoreKHR(ApiDumpInstance::current(), device, pSignalInfo); - } - } - VkResult result = device_dispatch_table(device)->SignalSemaphoreKHR(device, pSignalInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkSignalSemaphoreKHR(ApiDumpInstance::current(), device, pSignalInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkSignalSemaphoreKHR\n"; } + VkResult result = device_dispatch_table(device)->SignalSemaphoreKHR(device, pSignalInfo); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetFragmentShadingRateKHR", "commandBuffer, pFragmentSize, combinerOps", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetFragmentShadingRateKHR(ApiDumpInstance::current(), commandBuffer, pFragmentSize, combinerOps); - } - } - device_dispatch_table(commandBuffer)->CmdSetFragmentShadingRateKHR(commandBuffer, pFragmentSize, combinerOps); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetFragmentShadingRateKHR(ApiDumpInstance::current(), commandBuffer, pFragmentSize, combinerOps); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetFragmentShadingRateKHR\n"; } + device_dispatch_table(commandBuffer)->CmdSetFragmentShadingRateKHR(commandBuffer, pFragmentSize, combinerOps); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetRenderingAttachmentLocationsKHR(VkCommandBuffer commandBuffer, const VkRenderingAttachmentLocationInfo* pLocationInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetRenderingAttachmentLocationsKHR", "commandBuffer, pLocationInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetRenderingAttachmentLocationsKHR(ApiDumpInstance::current(), commandBuffer, pLocationInfo); - } - } - device_dispatch_table(commandBuffer)->CmdSetRenderingAttachmentLocationsKHR(commandBuffer, pLocationInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetRenderingAttachmentLocationsKHR(ApiDumpInstance::current(), commandBuffer, pLocationInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetRenderingAttachmentLocationsKHR\n"; } + device_dispatch_table(commandBuffer)->CmdSetRenderingAttachmentLocationsKHR(commandBuffer, pLocationInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetRenderingInputAttachmentIndicesKHR(VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetRenderingInputAttachmentIndicesKHR", "commandBuffer, pInputAttachmentIndexInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetRenderingInputAttachmentIndicesKHR(ApiDumpInstance::current(), commandBuffer, pInputAttachmentIndexInfo); - } - } - device_dispatch_table(commandBuffer)->CmdSetRenderingInputAttachmentIndicesKHR(commandBuffer, pInputAttachmentIndexInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetRenderingInputAttachmentIndicesKHR(ApiDumpInstance::current(), commandBuffer, pInputAttachmentIndexInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetRenderingInputAttachmentIndicesKHR\n"; } + device_dispatch_table(commandBuffer)->CmdSetRenderingInputAttachmentIndicesKHR(commandBuffer, pInputAttachmentIndexInfo); } template VKAPI_ATTR VkResult VKAPI_CALL vkWaitForPresentKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkWaitForPresentKHR", "device, swapchain, presentId, timeout", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkWaitForPresentKHR(ApiDumpInstance::current(), device, swapchain, presentId, timeout); - } - } - VkResult result = device_dispatch_table(device)->WaitForPresentKHR(device, swapchain, presentId, timeout); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkWaitForPresentKHR(ApiDumpInstance::current(), device, swapchain, presentId, timeout); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkWaitForPresentKHR\n"; } + VkResult result = device_dispatch_table(device)->WaitForPresentKHR(device, swapchain, presentId, timeout); return result; } template VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetBufferDeviceAddressKHR", "device, pInfo", "VkDeviceAddress"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetBufferDeviceAddressKHR(ApiDumpInstance::current(), device, pInfo); - } - } - VkDeviceAddress result = device_dispatch_table(device)->GetBufferDeviceAddressKHR(device, pInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkDeviceAddress", result, dump_return_value_VkDeviceAddress); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetBufferDeviceAddressKHR(ApiDumpInstance::current(), device, pInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetBufferDeviceAddressKHR\n"; } + VkDeviceAddress result = device_dispatch_table(device)->GetBufferDeviceAddressKHR(device, pInfo); return result; } template VKAPI_ATTR uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetBufferOpaqueCaptureAddressKHR", "device, pInfo", "uint64_t"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetBufferOpaqueCaptureAddressKHR(ApiDumpInstance::current(), device, pInfo); - } - } - uint64_t result = device_dispatch_table(device)->GetBufferOpaqueCaptureAddressKHR(device, pInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "uint64_t", result); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetBufferOpaqueCaptureAddressKHR(ApiDumpInstance::current(), device, pInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetBufferOpaqueCaptureAddressKHR\n"; } + uint64_t result = device_dispatch_table(device)->GetBufferOpaqueCaptureAddressKHR(device, pInfo); return result; } template VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddressKHR(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDeviceMemoryOpaqueCaptureAddressKHR", "device, pInfo", "uint64_t"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceMemoryOpaqueCaptureAddressKHR(ApiDumpInstance::current(), device, pInfo); - } - } - uint64_t result = device_dispatch_table(device)->GetDeviceMemoryOpaqueCaptureAddressKHR(device, pInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "uint64_t", result); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceMemoryOpaqueCaptureAddressKHR(ApiDumpInstance::current(), device, pInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDeviceMemoryOpaqueCaptureAddressKHR\n"; } + uint64_t result = device_dispatch_table(device)->GetDeviceMemoryOpaqueCaptureAddressKHR(device, pInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateDeferredOperationKHR(VkDevice device, const VkAllocationCallbacks* pAllocator, VkDeferredOperationKHR* pDeferredOperation) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateDeferredOperationKHR", "device, pAllocator, pDeferredOperation", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateDeferredOperationKHR(ApiDumpInstance::current(), device, pAllocator, pDeferredOperation); - } - } - VkResult result = device_dispatch_table(device)->CreateDeferredOperationKHR(device, pAllocator, pDeferredOperation); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateDeferredOperationKHR(ApiDumpInstance::current(), device, pAllocator, pDeferredOperation); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateDeferredOperationKHR\n"; } + VkResult result = device_dispatch_table(device)->CreateDeferredOperationKHR(device, pAllocator, pDeferredOperation); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyDeferredOperationKHR(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyDeferredOperationKHR", "device, operation, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyDeferredOperationKHR(ApiDumpInstance::current(), device, operation, pAllocator); - } - } - device_dispatch_table(device)->DestroyDeferredOperationKHR(device, operation, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyDeferredOperationKHR(ApiDumpInstance::current(), device, operation, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyDeferredOperationKHR\n"; } + device_dispatch_table(device)->DestroyDeferredOperationKHR(device, operation, pAllocator); } template VKAPI_ATTR uint32_t VKAPI_CALL vkGetDeferredOperationMaxConcurrencyKHR(VkDevice device, VkDeferredOperationKHR operation) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDeferredOperationMaxConcurrencyKHR", "device, operation", "uint32_t"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeferredOperationMaxConcurrencyKHR(ApiDumpInstance::current(), device, operation); - } - } - uint32_t result = device_dispatch_table(device)->GetDeferredOperationMaxConcurrencyKHR(device, operation); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "uint32_t", result); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeferredOperationMaxConcurrencyKHR(ApiDumpInstance::current(), device, operation); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDeferredOperationMaxConcurrencyKHR\n"; } + uint32_t result = device_dispatch_table(device)->GetDeferredOperationMaxConcurrencyKHR(device, operation); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetDeferredOperationResultKHR(VkDevice device, VkDeferredOperationKHR operation) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDeferredOperationResultKHR", "device, operation", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeferredOperationResultKHR(ApiDumpInstance::current(), device, operation); - } - } - VkResult result = device_dispatch_table(device)->GetDeferredOperationResultKHR(device, operation); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeferredOperationResultKHR(ApiDumpInstance::current(), device, operation); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDeferredOperationResultKHR\n"; } + VkResult result = device_dispatch_table(device)->GetDeferredOperationResultKHR(device, operation); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkDeferredOperationJoinKHR(VkDevice device, VkDeferredOperationKHR operation) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDeferredOperationJoinKHR", "device, operation", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDeferredOperationJoinKHR(ApiDumpInstance::current(), device, operation); - } - } - VkResult result = device_dispatch_table(device)->DeferredOperationJoinKHR(device, operation); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDeferredOperationJoinKHR(ApiDumpInstance::current(), device, operation); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDeferredOperationJoinKHR\n"; } + VkResult result = device_dispatch_table(device)->DeferredOperationJoinKHR(device, operation); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutablePropertiesKHR(VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPipelineExecutablePropertiesKHR", "device, pPipelineInfo, pExecutableCount, pProperties", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPipelineExecutablePropertiesKHR(ApiDumpInstance::current(), device, pPipelineInfo, pExecutableCount, pProperties); - } - } - VkResult result = device_dispatch_table(device)->GetPipelineExecutablePropertiesKHR(device, pPipelineInfo, pExecutableCount, pProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPipelineExecutablePropertiesKHR(ApiDumpInstance::current(), device, pPipelineInfo, pExecutableCount, pProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPipelineExecutablePropertiesKHR\n"; } + VkResult result = device_dispatch_table(device)->GetPipelineExecutablePropertiesKHR(device, pPipelineInfo, pExecutableCount, pProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableStatisticsKHR(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPipelineExecutableStatisticsKHR", "device, pExecutableInfo, pStatisticCount, pStatistics", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPipelineExecutableStatisticsKHR(ApiDumpInstance::current(), device, pExecutableInfo, pStatisticCount, pStatistics); - } - } - VkResult result = device_dispatch_table(device)->GetPipelineExecutableStatisticsKHR(device, pExecutableInfo, pStatisticCount, pStatistics); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPipelineExecutableStatisticsKHR(ApiDumpInstance::current(), device, pExecutableInfo, pStatisticCount, pStatistics); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPipelineExecutableStatisticsKHR\n"; } + VkResult result = device_dispatch_table(device)->GetPipelineExecutableStatisticsKHR(device, pExecutableInfo, pStatisticCount, pStatistics); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableInternalRepresentationsKHR(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPipelineExecutableInternalRepresentationsKHR", "device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPipelineExecutableInternalRepresentationsKHR(ApiDumpInstance::current(), device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations); - } - } - VkResult result = device_dispatch_table(device)->GetPipelineExecutableInternalRepresentationsKHR(device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPipelineExecutableInternalRepresentationsKHR(ApiDumpInstance::current(), device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPipelineExecutableInternalRepresentationsKHR\n"; } + VkResult result = device_dispatch_table(device)->GetPipelineExecutableInternalRepresentationsKHR(device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory2KHR(VkDevice device, const VkMemoryMapInfo* pMemoryMapInfo, void** ppData) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkMapMemory2KHR", "device, pMemoryMapInfo, ppData", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkMapMemory2KHR(ApiDumpInstance::current(), device, pMemoryMapInfo, ppData); - } - } - VkResult result = device_dispatch_table(device)->MapMemory2KHR(device, pMemoryMapInfo, ppData); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkMapMemory2KHR(ApiDumpInstance::current(), device, pMemoryMapInfo, ppData); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkMapMemory2KHR\n"; } + VkResult result = device_dispatch_table(device)->MapMemory2KHR(device, pMemoryMapInfo, ppData); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkUnmapMemory2KHR(VkDevice device, const VkMemoryUnmapInfo* pMemoryUnmapInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkUnmapMemory2KHR", "device, pMemoryUnmapInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkUnmapMemory2KHR(ApiDumpInstance::current(), device, pMemoryUnmapInfo); - } - } - VkResult result = device_dispatch_table(device)->UnmapMemory2KHR(device, pMemoryUnmapInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkUnmapMemory2KHR(ApiDumpInstance::current(), device, pMemoryUnmapInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkUnmapMemory2KHR\n"; } + VkResult result = device_dispatch_table(device)->UnmapMemory2KHR(device, pMemoryUnmapInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetEncodedVideoSessionParametersKHR(VkDevice device, const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, size_t* pDataSize, void* pData) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetEncodedVideoSessionParametersKHR", "device, pVideoSessionParametersInfo, pFeedbackInfo, pDataSize, pData", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetEncodedVideoSessionParametersKHR(ApiDumpInstance::current(), device, pVideoSessionParametersInfo, pFeedbackInfo, pDataSize, pData); - } - } - VkResult result = device_dispatch_table(device)->GetEncodedVideoSessionParametersKHR(device, pVideoSessionParametersInfo, pFeedbackInfo, pDataSize, pData); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetEncodedVideoSessionParametersKHR(ApiDumpInstance::current(), device, pVideoSessionParametersInfo, pFeedbackInfo, pDataSize, pData); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetEncodedVideoSessionParametersKHR\n"; } + VkResult result = device_dispatch_table(device)->GetEncodedVideoSessionParametersKHR(device, pVideoSessionParametersInfo, pFeedbackInfo, pDataSize, pData); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdEncodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdEncodeVideoKHR", "commandBuffer, pEncodeInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdEncodeVideoKHR(ApiDumpInstance::current(), commandBuffer, pEncodeInfo); - } - } - device_dispatch_table(commandBuffer)->CmdEncodeVideoKHR(commandBuffer, pEncodeInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdEncodeVideoKHR(ApiDumpInstance::current(), commandBuffer, pEncodeInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdEncodeVideoKHR\n"; } + device_dispatch_table(commandBuffer)->CmdEncodeVideoKHR(commandBuffer, pEncodeInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetEvent2KHR", "commandBuffer, event, pDependencyInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetEvent2KHR(ApiDumpInstance::current(), commandBuffer, event, pDependencyInfo); - } - } - device_dispatch_table(commandBuffer)->CmdSetEvent2KHR(commandBuffer, event, pDependencyInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetEvent2KHR(ApiDumpInstance::current(), commandBuffer, event, pDependencyInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetEvent2KHR\n"; } + device_dispatch_table(commandBuffer)->CmdSetEvent2KHR(commandBuffer, event, pDependencyInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdResetEvent2KHR", "commandBuffer, event, stageMask", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdResetEvent2KHR(ApiDumpInstance::current(), commandBuffer, event, stageMask); - } - } - device_dispatch_table(commandBuffer)->CmdResetEvent2KHR(commandBuffer, event, stageMask); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdResetEvent2KHR(ApiDumpInstance::current(), commandBuffer, event, stageMask); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdResetEvent2KHR\n"; } + device_dispatch_table(commandBuffer)->CmdResetEvent2KHR(commandBuffer, event, stageMask); } template VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdWaitEvents2KHR", "commandBuffer, eventCount, pEvents, pDependencyInfos", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdWaitEvents2KHR(ApiDumpInstance::current(), commandBuffer, eventCount, pEvents, pDependencyInfos); - } - } - device_dispatch_table(commandBuffer)->CmdWaitEvents2KHR(commandBuffer, eventCount, pEvents, pDependencyInfos); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdWaitEvents2KHR(ApiDumpInstance::current(), commandBuffer, eventCount, pEvents, pDependencyInfos); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdWaitEvents2KHR\n"; } + device_dispatch_table(commandBuffer)->CmdWaitEvents2KHR(commandBuffer, eventCount, pEvents, pDependencyInfos); } template VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdPipelineBarrier2KHR", "commandBuffer, pDependencyInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdPipelineBarrier2KHR(ApiDumpInstance::current(), commandBuffer, pDependencyInfo); - } - } - device_dispatch_table(commandBuffer)->CmdPipelineBarrier2KHR(commandBuffer, pDependencyInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdPipelineBarrier2KHR(ApiDumpInstance::current(), commandBuffer, pDependencyInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdPipelineBarrier2KHR\n"; } + device_dispatch_table(commandBuffer)->CmdPipelineBarrier2KHR(commandBuffer, pDependencyInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdWriteTimestamp2KHR", "commandBuffer, stage, queryPool, query", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdWriteTimestamp2KHR(ApiDumpInstance::current(), commandBuffer, stage, queryPool, query); - } - } - device_dispatch_table(commandBuffer)->CmdWriteTimestamp2KHR(commandBuffer, stage, queryPool, query); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdWriteTimestamp2KHR(ApiDumpInstance::current(), commandBuffer, stage, queryPool, query); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdWriteTimestamp2KHR\n"; } + device_dispatch_table(commandBuffer)->CmdWriteTimestamp2KHR(commandBuffer, stage, queryPool, query); } template VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit2KHR(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkQueueSubmit2KHR", "queue, submitCount, pSubmits, fence", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkQueueSubmit2KHR(ApiDumpInstance::current(), queue, submitCount, pSubmits, fence); - } - } - VkResult result = device_dispatch_table(queue)->QueueSubmit2KHR(queue, submitCount, pSubmits, fence); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkQueueSubmit2KHR(ApiDumpInstance::current(), queue, submitCount, pSubmits, fence); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkQueueSubmit2KHR\n"; } + VkResult result = device_dispatch_table(queue)->QueueSubmit2KHR(queue, submitCount, pSubmits, fence); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdCopyBuffer2KHR", "commandBuffer, pCopyBufferInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyBuffer2KHR(ApiDumpInstance::current(), commandBuffer, pCopyBufferInfo); - } - } - device_dispatch_table(commandBuffer)->CmdCopyBuffer2KHR(commandBuffer, pCopyBufferInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyBuffer2KHR(ApiDumpInstance::current(), commandBuffer, pCopyBufferInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdCopyBuffer2KHR\n"; } + device_dispatch_table(commandBuffer)->CmdCopyBuffer2KHR(commandBuffer, pCopyBufferInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdCopyImage2KHR", "commandBuffer, pCopyImageInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyImage2KHR(ApiDumpInstance::current(), commandBuffer, pCopyImageInfo); - } - } - device_dispatch_table(commandBuffer)->CmdCopyImage2KHR(commandBuffer, pCopyImageInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyImage2KHR(ApiDumpInstance::current(), commandBuffer, pCopyImageInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdCopyImage2KHR\n"; } + device_dispatch_table(commandBuffer)->CmdCopyImage2KHR(commandBuffer, pCopyImageInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdCopyBufferToImage2KHR", "commandBuffer, pCopyBufferToImageInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyBufferToImage2KHR(ApiDumpInstance::current(), commandBuffer, pCopyBufferToImageInfo); - } - } - device_dispatch_table(commandBuffer)->CmdCopyBufferToImage2KHR(commandBuffer, pCopyBufferToImageInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyBufferToImage2KHR(ApiDumpInstance::current(), commandBuffer, pCopyBufferToImageInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdCopyBufferToImage2KHR\n"; } + device_dispatch_table(commandBuffer)->CmdCopyBufferToImage2KHR(commandBuffer, pCopyBufferToImageInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdCopyImageToBuffer2KHR", "commandBuffer, pCopyImageToBufferInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyImageToBuffer2KHR(ApiDumpInstance::current(), commandBuffer, pCopyImageToBufferInfo); - } - } - device_dispatch_table(commandBuffer)->CmdCopyImageToBuffer2KHR(commandBuffer, pCopyImageToBufferInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyImageToBuffer2KHR(ApiDumpInstance::current(), commandBuffer, pCopyImageToBufferInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdCopyImageToBuffer2KHR\n"; } + device_dispatch_table(commandBuffer)->CmdCopyImageToBuffer2KHR(commandBuffer, pCopyImageToBufferInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBlitImage2KHR", "commandBuffer, pBlitImageInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBlitImage2KHR(ApiDumpInstance::current(), commandBuffer, pBlitImageInfo); - } - } - device_dispatch_table(commandBuffer)->CmdBlitImage2KHR(commandBuffer, pBlitImageInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBlitImage2KHR(ApiDumpInstance::current(), commandBuffer, pBlitImageInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBlitImage2KHR\n"; } + device_dispatch_table(commandBuffer)->CmdBlitImage2KHR(commandBuffer, pBlitImageInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdResolveImage2KHR", "commandBuffer, pResolveImageInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdResolveImage2KHR(ApiDumpInstance::current(), commandBuffer, pResolveImageInfo); - } - } - device_dispatch_table(commandBuffer)->CmdResolveImage2KHR(commandBuffer, pResolveImageInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdResolveImage2KHR(ApiDumpInstance::current(), commandBuffer, pResolveImageInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdResolveImage2KHR\n"; } + device_dispatch_table(commandBuffer)->CmdResolveImage2KHR(commandBuffer, pResolveImageInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysIndirect2KHR(VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdTraceRaysIndirect2KHR", "commandBuffer, indirectDeviceAddress", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdTraceRaysIndirect2KHR(ApiDumpInstance::current(), commandBuffer, indirectDeviceAddress); - } - } - device_dispatch_table(commandBuffer)->CmdTraceRaysIndirect2KHR(commandBuffer, indirectDeviceAddress); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdTraceRaysIndirect2KHR(ApiDumpInstance::current(), commandBuffer, indirectDeviceAddress); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdTraceRaysIndirect2KHR\n"; } + device_dispatch_table(commandBuffer)->CmdTraceRaysIndirect2KHR(commandBuffer, indirectDeviceAddress); } template VKAPI_ATTR void VKAPI_CALL vkGetDeviceBufferMemoryRequirementsKHR(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDeviceBufferMemoryRequirementsKHR", "device, pInfo, pMemoryRequirements", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceBufferMemoryRequirementsKHR(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements); - } - } - device_dispatch_table(device)->GetDeviceBufferMemoryRequirementsKHR(device, pInfo, pMemoryRequirements); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceBufferMemoryRequirementsKHR(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDeviceBufferMemoryRequirementsKHR\n"; } + device_dispatch_table(device)->GetDeviceBufferMemoryRequirementsKHR(device, pInfo, pMemoryRequirements); } template VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageMemoryRequirementsKHR(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDeviceImageMemoryRequirementsKHR", "device, pInfo, pMemoryRequirements", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceImageMemoryRequirementsKHR(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements); - } - } - device_dispatch_table(device)->GetDeviceImageMemoryRequirementsKHR(device, pInfo, pMemoryRequirements); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceImageMemoryRequirementsKHR(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDeviceImageMemoryRequirementsKHR\n"; } + device_dispatch_table(device)->GetDeviceImageMemoryRequirementsKHR(device, pInfo, pMemoryRequirements); } template VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSparseMemoryRequirementsKHR(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDeviceImageSparseMemoryRequirementsKHR", "device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceImageSparseMemoryRequirementsKHR(ApiDumpInstance::current(), device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); - } - } - device_dispatch_table(device)->GetDeviceImageSparseMemoryRequirementsKHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceImageSparseMemoryRequirementsKHR(ApiDumpInstance::current(), device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDeviceImageSparseMemoryRequirementsKHR\n"; } + device_dispatch_table(device)->GetDeviceImageSparseMemoryRequirementsKHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); } template VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer2KHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBindIndexBuffer2KHR", "commandBuffer, buffer, offset, size, indexType", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBindIndexBuffer2KHR(ApiDumpInstance::current(), commandBuffer, buffer, offset, size, indexType); - } - } - device_dispatch_table(commandBuffer)->CmdBindIndexBuffer2KHR(commandBuffer, buffer, offset, size, indexType); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBindIndexBuffer2KHR(ApiDumpInstance::current(), commandBuffer, buffer, offset, size, indexType); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBindIndexBuffer2KHR\n"; } + device_dispatch_table(commandBuffer)->CmdBindIndexBuffer2KHR(commandBuffer, buffer, offset, size, indexType); } template VKAPI_ATTR void VKAPI_CALL vkGetRenderingAreaGranularityKHR(VkDevice device, const VkRenderingAreaInfo* pRenderingAreaInfo, VkExtent2D* pGranularity) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetRenderingAreaGranularityKHR", "device, pRenderingAreaInfo, pGranularity", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetRenderingAreaGranularityKHR(ApiDumpInstance::current(), device, pRenderingAreaInfo, pGranularity); - } - } - device_dispatch_table(device)->GetRenderingAreaGranularityKHR(device, pRenderingAreaInfo, pGranularity); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetRenderingAreaGranularityKHR(ApiDumpInstance::current(), device, pRenderingAreaInfo, pGranularity); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetRenderingAreaGranularityKHR\n"; } + device_dispatch_table(device)->GetRenderingAreaGranularityKHR(device, pRenderingAreaInfo, pGranularity); } template VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSubresourceLayoutKHR(VkDevice device, const VkDeviceImageSubresourceInfo* pInfo, VkSubresourceLayout2* pLayout) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDeviceImageSubresourceLayoutKHR", "device, pInfo, pLayout", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceImageSubresourceLayoutKHR(ApiDumpInstance::current(), device, pInfo, pLayout); - } - } - device_dispatch_table(device)->GetDeviceImageSubresourceLayoutKHR(device, pInfo, pLayout); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceImageSubresourceLayoutKHR(ApiDumpInstance::current(), device, pInfo, pLayout); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDeviceImageSubresourceLayoutKHR\n"; } + device_dispatch_table(device)->GetDeviceImageSubresourceLayoutKHR(device, pInfo, pLayout); } template VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout2KHR(VkDevice device, VkImage image, const VkImageSubresource2* pSubresource, VkSubresourceLayout2* pLayout) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetImageSubresourceLayout2KHR", "device, image, pSubresource, pLayout", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetImageSubresourceLayout2KHR(ApiDumpInstance::current(), device, image, pSubresource, pLayout); - } - } - device_dispatch_table(device)->GetImageSubresourceLayout2KHR(device, image, pSubresource, pLayout); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetImageSubresourceLayout2KHR(ApiDumpInstance::current(), device, image, pSubresource, pLayout); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetImageSubresourceLayout2KHR\n"; } + device_dispatch_table(device)->GetImageSubresourceLayout2KHR(device, image, pSubresource, pLayout); } template VKAPI_ATTR VkResult VKAPI_CALL vkWaitForPresent2KHR(VkDevice device, VkSwapchainKHR swapchain, const VkPresentWait2InfoKHR* pPresentWait2Info) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkWaitForPresent2KHR", "device, swapchain, pPresentWait2Info", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkWaitForPresent2KHR(ApiDumpInstance::current(), device, swapchain, pPresentWait2Info); - } - } - VkResult result = device_dispatch_table(device)->WaitForPresent2KHR(device, swapchain, pPresentWait2Info); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkWaitForPresent2KHR(ApiDumpInstance::current(), device, swapchain, pPresentWait2Info); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkWaitForPresent2KHR\n"; } + VkResult result = device_dispatch_table(device)->WaitForPresent2KHR(device, swapchain, pPresentWait2Info); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineBinariesKHR(VkDevice device, const VkPipelineBinaryCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineBinaryHandlesInfoKHR* pBinaries) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreatePipelineBinariesKHR", "device, pCreateInfo, pAllocator, pBinaries", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreatePipelineBinariesKHR(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pBinaries); - } - } - VkResult result = device_dispatch_table(device)->CreatePipelineBinariesKHR(device, pCreateInfo, pAllocator, pBinaries); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreatePipelineBinariesKHR(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pBinaries); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreatePipelineBinariesKHR\n"; } + VkResult result = device_dispatch_table(device)->CreatePipelineBinariesKHR(device, pCreateInfo, pAllocator, pBinaries); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineBinaryKHR(VkDevice device, VkPipelineBinaryKHR pipelineBinary, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyPipelineBinaryKHR", "device, pipelineBinary, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyPipelineBinaryKHR(ApiDumpInstance::current(), device, pipelineBinary, pAllocator); - } - } - device_dispatch_table(device)->DestroyPipelineBinaryKHR(device, pipelineBinary, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyPipelineBinaryKHR(ApiDumpInstance::current(), device, pipelineBinary, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyPipelineBinaryKHR\n"; } + device_dispatch_table(device)->DestroyPipelineBinaryKHR(device, pipelineBinary, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineKeyKHR(VkDevice device, const VkPipelineCreateInfoKHR* pPipelineCreateInfo, VkPipelineBinaryKeyKHR* pPipelineKey) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPipelineKeyKHR", "device, pPipelineCreateInfo, pPipelineKey", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPipelineKeyKHR(ApiDumpInstance::current(), device, pPipelineCreateInfo, pPipelineKey); - } - } - VkResult result = device_dispatch_table(device)->GetPipelineKeyKHR(device, pPipelineCreateInfo, pPipelineKey); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPipelineKeyKHR(ApiDumpInstance::current(), device, pPipelineCreateInfo, pPipelineKey); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPipelineKeyKHR\n"; } + VkResult result = device_dispatch_table(device)->GetPipelineKeyKHR(device, pPipelineCreateInfo, pPipelineKey); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineBinaryDataKHR(VkDevice device, const VkPipelineBinaryDataInfoKHR* pInfo, VkPipelineBinaryKeyKHR* pPipelineBinaryKey, size_t* pPipelineBinaryDataSize, void* pPipelineBinaryData) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPipelineBinaryDataKHR", "device, pInfo, pPipelineBinaryKey, pPipelineBinaryDataSize, pPipelineBinaryData", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPipelineBinaryDataKHR(ApiDumpInstance::current(), device, pInfo, pPipelineBinaryKey, pPipelineBinaryDataSize, pPipelineBinaryData); - } - } - VkResult result = device_dispatch_table(device)->GetPipelineBinaryDataKHR(device, pInfo, pPipelineBinaryKey, pPipelineBinaryDataSize, pPipelineBinaryData); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPipelineBinaryDataKHR(ApiDumpInstance::current(), device, pInfo, pPipelineBinaryKey, pPipelineBinaryDataSize, pPipelineBinaryData); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPipelineBinaryDataKHR\n"; } + VkResult result = device_dispatch_table(device)->GetPipelineBinaryDataKHR(device, pInfo, pPipelineBinaryKey, pPipelineBinaryDataSize, pPipelineBinaryData); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkReleaseCapturedPipelineDataKHR(VkDevice device, const VkReleaseCapturedPipelineDataInfoKHR* pInfo, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkReleaseCapturedPipelineDataKHR", "device, pInfo, pAllocator", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkReleaseCapturedPipelineDataKHR(ApiDumpInstance::current(), device, pInfo, pAllocator); - } - } - VkResult result = device_dispatch_table(device)->ReleaseCapturedPipelineDataKHR(device, pInfo, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkReleaseCapturedPipelineDataKHR(ApiDumpInstance::current(), device, pInfo, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkReleaseCapturedPipelineDataKHR\n"; } + VkResult result = device_dispatch_table(device)->ReleaseCapturedPipelineDataKHR(device, pInfo, pAllocator); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkReleaseSwapchainImagesKHR(VkDevice device, const VkReleaseSwapchainImagesInfoKHR* pReleaseInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkReleaseSwapchainImagesKHR", "device, pReleaseInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkReleaseSwapchainImagesKHR(ApiDumpInstance::current(), device, pReleaseInfo); - } - } - VkResult result = device_dispatch_table(device)->ReleaseSwapchainImagesKHR(device, pReleaseInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkReleaseSwapchainImagesKHR(ApiDumpInstance::current(), device, pReleaseInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkReleaseSwapchainImagesKHR\n"; } + VkResult result = device_dispatch_table(device)->ReleaseSwapchainImagesKHR(device, pReleaseInfo); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleKHR(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetLineStippleKHR", "commandBuffer, lineStippleFactor, lineStipplePattern", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetLineStippleKHR(ApiDumpInstance::current(), commandBuffer, lineStippleFactor, lineStipplePattern); - } - } - device_dispatch_table(commandBuffer)->CmdSetLineStippleKHR(commandBuffer, lineStippleFactor, lineStipplePattern); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetLineStippleKHR(ApiDumpInstance::current(), commandBuffer, lineStippleFactor, lineStipplePattern); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetLineStippleKHR\n"; } + device_dispatch_table(commandBuffer)->CmdSetLineStippleKHR(commandBuffer, lineStippleFactor, lineStipplePattern); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetCalibratedTimestampsKHR(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetCalibratedTimestampsKHR", "device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetCalibratedTimestampsKHR(ApiDumpInstance::current(), device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation); - } - } - VkResult result = device_dispatch_table(device)->GetCalibratedTimestampsKHR(device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetCalibratedTimestampsKHR(ApiDumpInstance::current(), device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetCalibratedTimestampsKHR\n"; } + VkResult result = device_dispatch_table(device)->GetCalibratedTimestampsKHR(device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets2KHR(VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBindDescriptorSets2KHR", "commandBuffer, pBindDescriptorSetsInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBindDescriptorSets2KHR(ApiDumpInstance::current(), commandBuffer, pBindDescriptorSetsInfo); - } - } - device_dispatch_table(commandBuffer)->CmdBindDescriptorSets2KHR(commandBuffer, pBindDescriptorSetsInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBindDescriptorSets2KHR(ApiDumpInstance::current(), commandBuffer, pBindDescriptorSetsInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBindDescriptorSets2KHR\n"; } + device_dispatch_table(commandBuffer)->CmdBindDescriptorSets2KHR(commandBuffer, pBindDescriptorSetsInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants2KHR(VkCommandBuffer commandBuffer, const VkPushConstantsInfo* pPushConstantsInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdPushConstants2KHR", "commandBuffer, pPushConstantsInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdPushConstants2KHR(ApiDumpInstance::current(), commandBuffer, pPushConstantsInfo); - } - } - device_dispatch_table(commandBuffer)->CmdPushConstants2KHR(commandBuffer, pPushConstantsInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdPushConstants2KHR(ApiDumpInstance::current(), commandBuffer, pPushConstantsInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdPushConstants2KHR\n"; } + device_dispatch_table(commandBuffer)->CmdPushConstants2KHR(commandBuffer, pPushConstantsInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSet2KHR(VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfo* pPushDescriptorSetInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdPushDescriptorSet2KHR", "commandBuffer, pPushDescriptorSetInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdPushDescriptorSet2KHR(ApiDumpInstance::current(), commandBuffer, pPushDescriptorSetInfo); - } - } - device_dispatch_table(commandBuffer)->CmdPushDescriptorSet2KHR(commandBuffer, pPushDescriptorSetInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdPushDescriptorSet2KHR(ApiDumpInstance::current(), commandBuffer, pPushDescriptorSetInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdPushDescriptorSet2KHR\n"; } + device_dispatch_table(commandBuffer)->CmdPushDescriptorSet2KHR(commandBuffer, pPushDescriptorSetInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplate2KHR(VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdPushDescriptorSetWithTemplate2KHR", "commandBuffer, pPushDescriptorSetWithTemplateInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdPushDescriptorSetWithTemplate2KHR(ApiDumpInstance::current(), commandBuffer, pPushDescriptorSetWithTemplateInfo); - } - } - device_dispatch_table(commandBuffer)->CmdPushDescriptorSetWithTemplate2KHR(commandBuffer, pPushDescriptorSetWithTemplateInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdPushDescriptorSetWithTemplate2KHR(ApiDumpInstance::current(), commandBuffer, pPushDescriptorSetWithTemplateInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdPushDescriptorSetWithTemplate2KHR\n"; } + device_dispatch_table(commandBuffer)->CmdPushDescriptorSetWithTemplate2KHR(commandBuffer, pPushDescriptorSetWithTemplateInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDescriptorBufferOffsets2EXT(VkCommandBuffer commandBuffer, const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetDescriptorBufferOffsets2EXT", "commandBuffer, pSetDescriptorBufferOffsetsInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDescriptorBufferOffsets2EXT(ApiDumpInstance::current(), commandBuffer, pSetDescriptorBufferOffsetsInfo); - } - } - device_dispatch_table(commandBuffer)->CmdSetDescriptorBufferOffsets2EXT(commandBuffer, pSetDescriptorBufferOffsetsInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDescriptorBufferOffsets2EXT(ApiDumpInstance::current(), commandBuffer, pSetDescriptorBufferOffsetsInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetDescriptorBufferOffsets2EXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetDescriptorBufferOffsets2EXT(commandBuffer, pSetDescriptorBufferOffsetsInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT", "commandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(ApiDumpInstance::current(), commandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo); - } - } - device_dispatch_table(commandBuffer)->CmdBindDescriptorBufferEmbeddedSamplers2EXT(commandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(ApiDumpInstance::current(), commandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT\n"; } + device_dispatch_table(commandBuffer)->CmdBindDescriptorBufferEmbeddedSamplers2EXT(commandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryIndirectKHR(VkCommandBuffer commandBuffer, const VkCopyMemoryIndirectInfoKHR* pCopyMemoryIndirectInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdCopyMemoryIndirectKHR", "commandBuffer, pCopyMemoryIndirectInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyMemoryIndirectKHR(ApiDumpInstance::current(), commandBuffer, pCopyMemoryIndirectInfo); - } - } - device_dispatch_table(commandBuffer)->CmdCopyMemoryIndirectKHR(commandBuffer, pCopyMemoryIndirectInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyMemoryIndirectKHR(ApiDumpInstance::current(), commandBuffer, pCopyMemoryIndirectInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdCopyMemoryIndirectKHR\n"; } + device_dispatch_table(commandBuffer)->CmdCopyMemoryIndirectKHR(commandBuffer, pCopyMemoryIndirectInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToImageIndirectKHR(VkCommandBuffer commandBuffer, const VkCopyMemoryToImageIndirectInfoKHR* pCopyMemoryToImageIndirectInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdCopyMemoryToImageIndirectKHR", "commandBuffer, pCopyMemoryToImageIndirectInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyMemoryToImageIndirectKHR(ApiDumpInstance::current(), commandBuffer, pCopyMemoryToImageIndirectInfo); - } - } - device_dispatch_table(commandBuffer)->CmdCopyMemoryToImageIndirectKHR(commandBuffer, pCopyMemoryToImageIndirectInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyMemoryToImageIndirectKHR(ApiDumpInstance::current(), commandBuffer, pCopyMemoryToImageIndirectInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdCopyMemoryToImageIndirectKHR\n"; } + device_dispatch_table(commandBuffer)->CmdCopyMemoryToImageIndirectKHR(commandBuffer, pCopyMemoryToImageIndirectInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdEndRendering2KHR(VkCommandBuffer commandBuffer, const VkRenderingEndInfoKHR* pRenderingEndInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdEndRendering2KHR", "commandBuffer, pRenderingEndInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdEndRendering2KHR(ApiDumpInstance::current(), commandBuffer, pRenderingEndInfo); - } - } - device_dispatch_table(commandBuffer)->CmdEndRendering2KHR(commandBuffer, pRenderingEndInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdEndRendering2KHR(ApiDumpInstance::current(), commandBuffer, pRenderingEndInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdEndRendering2KHR\n"; } + device_dispatch_table(commandBuffer)->CmdEndRendering2KHR(commandBuffer, pRenderingEndInfo); } template VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDebugMarkerSetObjectTagEXT", "device, pTagInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDebugMarkerSetObjectTagEXT(ApiDumpInstance::current(), device, pTagInfo); - } - } - VkResult result = device_dispatch_table(device)->DebugMarkerSetObjectTagEXT(device, pTagInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDebugMarkerSetObjectTagEXT(ApiDumpInstance::current(), device, pTagInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDebugMarkerSetObjectTagEXT\n"; } + VkResult result = device_dispatch_table(device)->DebugMarkerSetObjectTagEXT(device, pTagInfo); return result; } template @@ -8591,434 +4100,206 @@ VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectNameEXT(VkDevice device, co std::lock_guard lg(ApiDumpInstance::current().outputMutex()); ApiDumpInstance::current().update_object_name_map(pNameInfo); - dump_function_head(ApiDumpInstance::current(), "vkDebugMarkerSetObjectNameEXT", "device, pNameInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDebugMarkerSetObjectNameEXT(ApiDumpInstance::current(), device, pNameInfo); - } - } - VkResult result = device_dispatch_table(device)->DebugMarkerSetObjectNameEXT(device, pNameInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDebugMarkerSetObjectNameEXT(ApiDumpInstance::current(), device, pNameInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDebugMarkerSetObjectNameEXT\n"; } + VkResult result = device_dispatch_table(device)->DebugMarkerSetObjectNameEXT(device, pNameInfo); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdDebugMarkerBeginEXT", "commandBuffer, pMarkerInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDebugMarkerBeginEXT(ApiDumpInstance::current(), commandBuffer, pMarkerInfo); - } - } - device_dispatch_table(commandBuffer)->CmdDebugMarkerBeginEXT(commandBuffer, pMarkerInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDebugMarkerBeginEXT(ApiDumpInstance::current(), commandBuffer, pMarkerInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdDebugMarkerBeginEXT\n"; } + device_dispatch_table(commandBuffer)->CmdDebugMarkerBeginEXT(commandBuffer, pMarkerInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdDebugMarkerEndEXT", "commandBuffer", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDebugMarkerEndEXT(ApiDumpInstance::current(), commandBuffer); - } - } - device_dispatch_table(commandBuffer)->CmdDebugMarkerEndEXT(commandBuffer); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDebugMarkerEndEXT(ApiDumpInstance::current(), commandBuffer); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdDebugMarkerEndEXT\n"; } + device_dispatch_table(commandBuffer)->CmdDebugMarkerEndEXT(commandBuffer); } template VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdDebugMarkerInsertEXT", "commandBuffer, pMarkerInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDebugMarkerInsertEXT(ApiDumpInstance::current(), commandBuffer, pMarkerInfo); - } - } - device_dispatch_table(commandBuffer)->CmdDebugMarkerInsertEXT(commandBuffer, pMarkerInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDebugMarkerInsertEXT(ApiDumpInstance::current(), commandBuffer, pMarkerInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdDebugMarkerInsertEXT\n"; } + device_dispatch_table(commandBuffer)->CmdDebugMarkerInsertEXT(commandBuffer, pMarkerInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBindTransformFeedbackBuffersEXT", "commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBindTransformFeedbackBuffersEXT(ApiDumpInstance::current(), commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes); - } - } - device_dispatch_table(commandBuffer)->CmdBindTransformFeedbackBuffersEXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBindTransformFeedbackBuffersEXT(ApiDumpInstance::current(), commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBindTransformFeedbackBuffersEXT\n"; } + device_dispatch_table(commandBuffer)->CmdBindTransformFeedbackBuffersEXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes); } template VKAPI_ATTR void VKAPI_CALL vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBeginTransformFeedbackEXT", "commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBeginTransformFeedbackEXT(ApiDumpInstance::current(), commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); - } - } - device_dispatch_table(commandBuffer)->CmdBeginTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBeginTransformFeedbackEXT(ApiDumpInstance::current(), commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBeginTransformFeedbackEXT\n"; } + device_dispatch_table(commandBuffer)->CmdBeginTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); } template VKAPI_ATTR void VKAPI_CALL vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdEndTransformFeedbackEXT", "commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdEndTransformFeedbackEXT(ApiDumpInstance::current(), commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); - } - } - device_dispatch_table(commandBuffer)->CmdEndTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdEndTransformFeedbackEXT(ApiDumpInstance::current(), commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdEndTransformFeedbackEXT\n"; } + device_dispatch_table(commandBuffer)->CmdEndTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); } template VKAPI_ATTR void VKAPI_CALL vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBeginQueryIndexedEXT", "commandBuffer, queryPool, query, flags, index", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBeginQueryIndexedEXT(ApiDumpInstance::current(), commandBuffer, queryPool, query, flags, index); - } - } - device_dispatch_table(commandBuffer)->CmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBeginQueryIndexedEXT(ApiDumpInstance::current(), commandBuffer, queryPool, query, flags, index); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBeginQueryIndexedEXT\n"; } + device_dispatch_table(commandBuffer)->CmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index); } template VKAPI_ATTR void VKAPI_CALL vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdEndQueryIndexedEXT", "commandBuffer, queryPool, query, index", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdEndQueryIndexedEXT(ApiDumpInstance::current(), commandBuffer, queryPool, query, index); - } - } - device_dispatch_table(commandBuffer)->CmdEndQueryIndexedEXT(commandBuffer, queryPool, query, index); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdEndQueryIndexedEXT(ApiDumpInstance::current(), commandBuffer, queryPool, query, index); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdEndQueryIndexedEXT\n"; } + device_dispatch_table(commandBuffer)->CmdEndQueryIndexedEXT(commandBuffer, queryPool, query, index); } template VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdDrawIndirectByteCountEXT", "commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDrawIndirectByteCountEXT(ApiDumpInstance::current(), commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride); - } - } - device_dispatch_table(commandBuffer)->CmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDrawIndirectByteCountEXT(ApiDumpInstance::current(), commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdDrawIndirectByteCountEXT\n"; } + device_dispatch_table(commandBuffer)->CmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateCuModuleNVX(VkDevice device, const VkCuModuleCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuModuleNVX* pModule) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateCuModuleNVX", "device, pCreateInfo, pAllocator, pModule", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateCuModuleNVX(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pModule); - } - } - VkResult result = device_dispatch_table(device)->CreateCuModuleNVX(device, pCreateInfo, pAllocator, pModule); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateCuModuleNVX(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pModule); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateCuModuleNVX\n"; } + VkResult result = device_dispatch_table(device)->CreateCuModuleNVX(device, pCreateInfo, pAllocator, pModule); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateCuFunctionNVX(VkDevice device, const VkCuFunctionCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuFunctionNVX* pFunction) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateCuFunctionNVX", "device, pCreateInfo, pAllocator, pFunction", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateCuFunctionNVX(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pFunction); - } - } - VkResult result = device_dispatch_table(device)->CreateCuFunctionNVX(device, pCreateInfo, pAllocator, pFunction); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateCuFunctionNVX(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pFunction); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateCuFunctionNVX\n"; } + VkResult result = device_dispatch_table(device)->CreateCuFunctionNVX(device, pCreateInfo, pAllocator, pFunction); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyCuModuleNVX(VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyCuModuleNVX", "device, module, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyCuModuleNVX(ApiDumpInstance::current(), device, module, pAllocator); - } - } - device_dispatch_table(device)->DestroyCuModuleNVX(device, module, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyCuModuleNVX(ApiDumpInstance::current(), device, module, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyCuModuleNVX\n"; } + device_dispatch_table(device)->DestroyCuModuleNVX(device, module, pAllocator); } template VKAPI_ATTR void VKAPI_CALL vkDestroyCuFunctionNVX(VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyCuFunctionNVX", "device, function, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyCuFunctionNVX(ApiDumpInstance::current(), device, function, pAllocator); - } - } - device_dispatch_table(device)->DestroyCuFunctionNVX(device, function, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyCuFunctionNVX(ApiDumpInstance::current(), device, function, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyCuFunctionNVX\n"; } + device_dispatch_table(device)->DestroyCuFunctionNVX(device, function, pAllocator); } template VKAPI_ATTR void VKAPI_CALL vkCmdCuLaunchKernelNVX(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdCuLaunchKernelNVX", "commandBuffer, pLaunchInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCuLaunchKernelNVX(ApiDumpInstance::current(), commandBuffer, pLaunchInfo); - } - } - device_dispatch_table(commandBuffer)->CmdCuLaunchKernelNVX(commandBuffer, pLaunchInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCuLaunchKernelNVX(ApiDumpInstance::current(), commandBuffer, pLaunchInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdCuLaunchKernelNVX\n"; } + device_dispatch_table(commandBuffer)->CmdCuLaunchKernelNVX(commandBuffer, pLaunchInfo); } template VKAPI_ATTR uint32_t VKAPI_CALL vkGetImageViewHandleNVX(VkDevice device, const VkImageViewHandleInfoNVX* pInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetImageViewHandleNVX", "device, pInfo", "uint32_t"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetImageViewHandleNVX(ApiDumpInstance::current(), device, pInfo); - } - } - uint32_t result = device_dispatch_table(device)->GetImageViewHandleNVX(device, pInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "uint32_t", result); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetImageViewHandleNVX(ApiDumpInstance::current(), device, pInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetImageViewHandleNVX\n"; } + uint32_t result = device_dispatch_table(device)->GetImageViewHandleNVX(device, pInfo); return result; } template VKAPI_ATTR uint64_t VKAPI_CALL vkGetImageViewHandle64NVX(VkDevice device, const VkImageViewHandleInfoNVX* pInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetImageViewHandle64NVX", "device, pInfo", "uint64_t"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetImageViewHandle64NVX(ApiDumpInstance::current(), device, pInfo); - } - } - uint64_t result = device_dispatch_table(device)->GetImageViewHandle64NVX(device, pInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "uint64_t", result); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetImageViewHandle64NVX(ApiDumpInstance::current(), device, pInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetImageViewHandle64NVX\n"; } + uint64_t result = device_dispatch_table(device)->GetImageViewHandle64NVX(device, pInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetImageViewAddressNVX(VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX* pProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetImageViewAddressNVX", "device, imageView, pProperties", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetImageViewAddressNVX(ApiDumpInstance::current(), device, imageView, pProperties); - } - } - VkResult result = device_dispatch_table(device)->GetImageViewAddressNVX(device, imageView, pProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetImageViewAddressNVX(ApiDumpInstance::current(), device, imageView, pProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetImageViewAddressNVX\n"; } + VkResult result = device_dispatch_table(device)->GetImageViewAddressNVX(device, imageView, pProperties); return result; } template VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceCombinedImageSamplerIndexNVX(VkDevice device, uint64_t imageViewIndex, uint64_t samplerIndex) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDeviceCombinedImageSamplerIndexNVX", "device, imageViewIndex, samplerIndex", "uint64_t"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceCombinedImageSamplerIndexNVX(ApiDumpInstance::current(), device, imageViewIndex, samplerIndex); - } - } - uint64_t result = device_dispatch_table(device)->GetDeviceCombinedImageSamplerIndexNVX(device, imageViewIndex, samplerIndex); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "uint64_t", result); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceCombinedImageSamplerIndexNVX(ApiDumpInstance::current(), device, imageViewIndex, samplerIndex); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDeviceCombinedImageSamplerIndexNVX\n"; } + uint64_t result = device_dispatch_table(device)->GetDeviceCombinedImageSamplerIndexNVX(device, imageViewIndex, samplerIndex); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdDrawIndirectCountAMD", "commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDrawIndirectCountAMD(ApiDumpInstance::current(), commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); - } - } - device_dispatch_table(commandBuffer)->CmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDrawIndirectCountAMD(ApiDumpInstance::current(), commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdDrawIndirectCountAMD\n"; } + device_dispatch_table(commandBuffer)->CmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); } template VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdDrawIndexedIndirectCountAMD", "commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDrawIndexedIndirectCountAMD(ApiDumpInstance::current(), commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); - } - } - device_dispatch_table(commandBuffer)->CmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDrawIndexedIndirectCountAMD(ApiDumpInstance::current(), commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdDrawIndexedIndirectCountAMD\n"; } + device_dispatch_table(commandBuffer)->CmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetShaderInfoAMD", "device, pipeline, shaderStage, infoType, pInfoSize, pInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetShaderInfoAMD(ApiDumpInstance::current(), device, pipeline, shaderStage, infoType, pInfoSize, pInfo); - } - } - VkResult result = device_dispatch_table(device)->GetShaderInfoAMD(device, pipeline, shaderStage, infoType, pInfoSize, pInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetShaderInfoAMD(ApiDumpInstance::current(), device, pipeline, shaderStage, infoType, pInfoSize, pInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetShaderInfoAMD\n"; } + VkResult result = device_dispatch_table(device)->GetShaderInfoAMD(device, pipeline, shaderStage, infoType, pInfoSize, pInfo); return result; } #if defined(VK_USE_PLATFORM_WIN32_KHR) @@ -9026,21 +4307,10 @@ template VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetMemoryWin32HandleNV", "device, memory, handleType, pHandle", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetMemoryWin32HandleNV(ApiDumpInstance::current(), device, memory, handleType, pHandle); - } - } - VkResult result = device_dispatch_table(device)->GetMemoryWin32HandleNV(device, memory, handleType, pHandle); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetMemoryWin32HandleNV(ApiDumpInstance::current(), device, memory, handleType, pHandle); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetMemoryWin32HandleNV\n"; } + VkResult result = device_dispatch_table(device)->GetMemoryWin32HandleNV(device, memory, handleType, pHandle); return result; } #endif // VK_USE_PLATFORM_WIN32_KHR @@ -9048,459 +4318,219 @@ template VKAPI_ATTR void VKAPI_CALL vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBeginConditionalRenderingEXT", "commandBuffer, pConditionalRenderingBegin", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBeginConditionalRenderingEXT(ApiDumpInstance::current(), commandBuffer, pConditionalRenderingBegin); - } - } - device_dispatch_table(commandBuffer)->CmdBeginConditionalRenderingEXT(commandBuffer, pConditionalRenderingBegin); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBeginConditionalRenderingEXT(ApiDumpInstance::current(), commandBuffer, pConditionalRenderingBegin); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBeginConditionalRenderingEXT\n"; } + device_dispatch_table(commandBuffer)->CmdBeginConditionalRenderingEXT(commandBuffer, pConditionalRenderingBegin); } template VKAPI_ATTR void VKAPI_CALL vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdEndConditionalRenderingEXT", "commandBuffer", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdEndConditionalRenderingEXT(ApiDumpInstance::current(), commandBuffer); - } - } - device_dispatch_table(commandBuffer)->CmdEndConditionalRenderingEXT(commandBuffer); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdEndConditionalRenderingEXT(ApiDumpInstance::current(), commandBuffer); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdEndConditionalRenderingEXT\n"; } + device_dispatch_table(commandBuffer)->CmdEndConditionalRenderingEXT(commandBuffer); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetViewportWScalingNV", "commandBuffer, firstViewport, viewportCount, pViewportWScalings", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetViewportWScalingNV(ApiDumpInstance::current(), commandBuffer, firstViewport, viewportCount, pViewportWScalings); - } - } - device_dispatch_table(commandBuffer)->CmdSetViewportWScalingNV(commandBuffer, firstViewport, viewportCount, pViewportWScalings); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetViewportWScalingNV(ApiDumpInstance::current(), commandBuffer, firstViewport, viewportCount, pViewportWScalings); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetViewportWScalingNV\n"; } + device_dispatch_table(commandBuffer)->CmdSetViewportWScalingNV(commandBuffer, firstViewport, viewportCount, pViewportWScalings); } template VKAPI_ATTR VkResult VKAPI_CALL vkDisplayPowerControlEXT(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDisplayPowerControlEXT", "device, display, pDisplayPowerInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDisplayPowerControlEXT(ApiDumpInstance::current(), device, display, pDisplayPowerInfo); - } - } - VkResult result = device_dispatch_table(device)->DisplayPowerControlEXT(device, display, pDisplayPowerInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDisplayPowerControlEXT(ApiDumpInstance::current(), device, display, pDisplayPowerInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDisplayPowerControlEXT\n"; } + VkResult result = device_dispatch_table(device)->DisplayPowerControlEXT(device, display, pDisplayPowerInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDeviceEventEXT(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkRegisterDeviceEventEXT", "device, pDeviceEventInfo, pAllocator, pFence", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkRegisterDeviceEventEXT(ApiDumpInstance::current(), device, pDeviceEventInfo, pAllocator, pFence); - } - } - VkResult result = device_dispatch_table(device)->RegisterDeviceEventEXT(device, pDeviceEventInfo, pAllocator, pFence); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkRegisterDeviceEventEXT(ApiDumpInstance::current(), device, pDeviceEventInfo, pAllocator, pFence); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkRegisterDeviceEventEXT\n"; } + VkResult result = device_dispatch_table(device)->RegisterDeviceEventEXT(device, pDeviceEventInfo, pAllocator, pFence); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDisplayEventEXT(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkRegisterDisplayEventEXT", "device, display, pDisplayEventInfo, pAllocator, pFence", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkRegisterDisplayEventEXT(ApiDumpInstance::current(), device, display, pDisplayEventInfo, pAllocator, pFence); - } - } - VkResult result = device_dispatch_table(device)->RegisterDisplayEventEXT(device, display, pDisplayEventInfo, pAllocator, pFence); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkRegisterDisplayEventEXT(ApiDumpInstance::current(), device, display, pDisplayEventInfo, pAllocator, pFence); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkRegisterDisplayEventEXT\n"; } + VkResult result = device_dispatch_table(device)->RegisterDisplayEventEXT(device, display, pDisplayEventInfo, pAllocator, pFence); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainCounterEXT(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetSwapchainCounterEXT", "device, swapchain, counter, pCounterValue", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetSwapchainCounterEXT(ApiDumpInstance::current(), device, swapchain, counter, pCounterValue); - } - } - VkResult result = device_dispatch_table(device)->GetSwapchainCounterEXT(device, swapchain, counter, pCounterValue); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetSwapchainCounterEXT(ApiDumpInstance::current(), device, swapchain, counter, pCounterValue); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetSwapchainCounterEXT\n"; } + VkResult result = device_dispatch_table(device)->GetSwapchainCounterEXT(device, swapchain, counter, pCounterValue); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetRefreshCycleDurationGOOGLE(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetRefreshCycleDurationGOOGLE", "device, swapchain, pDisplayTimingProperties", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetRefreshCycleDurationGOOGLE(ApiDumpInstance::current(), device, swapchain, pDisplayTimingProperties); - } - } - VkResult result = device_dispatch_table(device)->GetRefreshCycleDurationGOOGLE(device, swapchain, pDisplayTimingProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetRefreshCycleDurationGOOGLE(ApiDumpInstance::current(), device, swapchain, pDisplayTimingProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetRefreshCycleDurationGOOGLE\n"; } + VkResult result = device_dispatch_table(device)->GetRefreshCycleDurationGOOGLE(device, swapchain, pDisplayTimingProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPastPresentationTimingGOOGLE(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPastPresentationTimingGOOGLE", "device, swapchain, pPresentationTimingCount, pPresentationTimings", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPastPresentationTimingGOOGLE(ApiDumpInstance::current(), device, swapchain, pPresentationTimingCount, pPresentationTimings); - } - } - VkResult result = device_dispatch_table(device)->GetPastPresentationTimingGOOGLE(device, swapchain, pPresentationTimingCount, pPresentationTimings); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPastPresentationTimingGOOGLE(ApiDumpInstance::current(), device, swapchain, pPresentationTimingCount, pPresentationTimings); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPastPresentationTimingGOOGLE\n"; } + VkResult result = device_dispatch_table(device)->GetPastPresentationTimingGOOGLE(device, swapchain, pPresentationTimingCount, pPresentationTimings); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetDiscardRectangleEXT", "commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDiscardRectangleEXT(ApiDumpInstance::current(), commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles); - } - } - device_dispatch_table(commandBuffer)->CmdSetDiscardRectangleEXT(commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDiscardRectangleEXT(ApiDumpInstance::current(), commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetDiscardRectangleEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetDiscardRectangleEXT(commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetDiscardRectangleEnableEXT", "commandBuffer, discardRectangleEnable", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDiscardRectangleEnableEXT(ApiDumpInstance::current(), commandBuffer, discardRectangleEnable); - } - } - device_dispatch_table(commandBuffer)->CmdSetDiscardRectangleEnableEXT(commandBuffer, discardRectangleEnable); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDiscardRectangleEnableEXT(ApiDumpInstance::current(), commandBuffer, discardRectangleEnable); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetDiscardRectangleEnableEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetDiscardRectangleEnableEXT(commandBuffer, discardRectangleEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleModeEXT(VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetDiscardRectangleModeEXT", "commandBuffer, discardRectangleMode", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDiscardRectangleModeEXT(ApiDumpInstance::current(), commandBuffer, discardRectangleMode); - } - } - device_dispatch_table(commandBuffer)->CmdSetDiscardRectangleModeEXT(commandBuffer, discardRectangleMode); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDiscardRectangleModeEXT(ApiDumpInstance::current(), commandBuffer, discardRectangleMode); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetDiscardRectangleModeEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetDiscardRectangleModeEXT(commandBuffer, discardRectangleMode); } template VKAPI_ATTR void VKAPI_CALL vkSetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkSetHdrMetadataEXT", "device, swapchainCount, pSwapchains, pMetadata", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkSetHdrMetadataEXT(ApiDumpInstance::current(), device, swapchainCount, pSwapchains, pMetadata); - } - } - device_dispatch_table(device)->SetHdrMetadataEXT(device, swapchainCount, pSwapchains, pMetadata); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkSetHdrMetadataEXT(ApiDumpInstance::current(), device, swapchainCount, pSwapchains, pMetadata); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkSetHdrMetadataEXT\n"; } + device_dispatch_table(device)->SetHdrMetadataEXT(device, swapchainCount, pSwapchains, pMetadata); } template VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); ApiDumpInstance::current().update_object_name_map(pNameInfo); - dump_function_head(ApiDumpInstance::current(), "vkSetDebugUtilsObjectNameEXT", "device, pNameInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkSetDebugUtilsObjectNameEXT(ApiDumpInstance::current(), device, pNameInfo); - } - } - VkResult result = device_dispatch_table(device)->SetDebugUtilsObjectNameEXT(device, pNameInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkSetDebugUtilsObjectNameEXT(ApiDumpInstance::current(), device, pNameInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkSetDebugUtilsObjectNameEXT\n"; } + VkResult result = device_dispatch_table(device)->SetDebugUtilsObjectNameEXT(device, pNameInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkSetDebugUtilsObjectTagEXT", "device, pTagInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkSetDebugUtilsObjectTagEXT(ApiDumpInstance::current(), device, pTagInfo); - } - } - VkResult result = device_dispatch_table(device)->SetDebugUtilsObjectTagEXT(device, pTagInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkSetDebugUtilsObjectTagEXT(ApiDumpInstance::current(), device, pTagInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkSetDebugUtilsObjectTagEXT\n"; } + VkResult result = device_dispatch_table(device)->SetDebugUtilsObjectTagEXT(device, pTagInfo); return result; } template VKAPI_ATTR void VKAPI_CALL vkQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkQueueBeginDebugUtilsLabelEXT", "queue, pLabelInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkQueueBeginDebugUtilsLabelEXT(ApiDumpInstance::current(), queue, pLabelInfo); - } - } - device_dispatch_table(queue)->QueueBeginDebugUtilsLabelEXT(queue, pLabelInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkQueueBeginDebugUtilsLabelEXT(ApiDumpInstance::current(), queue, pLabelInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkQueueBeginDebugUtilsLabelEXT\n"; } + device_dispatch_table(queue)->QueueBeginDebugUtilsLabelEXT(queue, pLabelInfo); } template VKAPI_ATTR void VKAPI_CALL vkQueueEndDebugUtilsLabelEXT(VkQueue queue) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkQueueEndDebugUtilsLabelEXT", "queue", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkQueueEndDebugUtilsLabelEXT(ApiDumpInstance::current(), queue); - } - } - device_dispatch_table(queue)->QueueEndDebugUtilsLabelEXT(queue); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkQueueEndDebugUtilsLabelEXT(ApiDumpInstance::current(), queue); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkQueueEndDebugUtilsLabelEXT\n"; } + device_dispatch_table(queue)->QueueEndDebugUtilsLabelEXT(queue); } template VKAPI_ATTR void VKAPI_CALL vkQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkQueueInsertDebugUtilsLabelEXT", "queue, pLabelInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkQueueInsertDebugUtilsLabelEXT(ApiDumpInstance::current(), queue, pLabelInfo); - } - } - device_dispatch_table(queue)->QueueInsertDebugUtilsLabelEXT(queue, pLabelInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkQueueInsertDebugUtilsLabelEXT(ApiDumpInstance::current(), queue, pLabelInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkQueueInsertDebugUtilsLabelEXT\n"; } + device_dispatch_table(queue)->QueueInsertDebugUtilsLabelEXT(queue, pLabelInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBeginDebugUtilsLabelEXT", "commandBuffer, pLabelInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBeginDebugUtilsLabelEXT(ApiDumpInstance::current(), commandBuffer, pLabelInfo); - } - } - device_dispatch_table(commandBuffer)->CmdBeginDebugUtilsLabelEXT(commandBuffer, pLabelInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBeginDebugUtilsLabelEXT(ApiDumpInstance::current(), commandBuffer, pLabelInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBeginDebugUtilsLabelEXT\n"; } + device_dispatch_table(commandBuffer)->CmdBeginDebugUtilsLabelEXT(commandBuffer, pLabelInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdEndDebugUtilsLabelEXT", "commandBuffer", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdEndDebugUtilsLabelEXT(ApiDumpInstance::current(), commandBuffer); - } - } - device_dispatch_table(commandBuffer)->CmdEndDebugUtilsLabelEXT(commandBuffer); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdEndDebugUtilsLabelEXT(ApiDumpInstance::current(), commandBuffer); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdEndDebugUtilsLabelEXT\n"; } + device_dispatch_table(commandBuffer)->CmdEndDebugUtilsLabelEXT(commandBuffer); } template VKAPI_ATTR void VKAPI_CALL vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdInsertDebugUtilsLabelEXT", "commandBuffer, pLabelInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdInsertDebugUtilsLabelEXT(ApiDumpInstance::current(), commandBuffer, pLabelInfo); - } - } - device_dispatch_table(commandBuffer)->CmdInsertDebugUtilsLabelEXT(commandBuffer, pLabelInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdInsertDebugUtilsLabelEXT(ApiDumpInstance::current(), commandBuffer, pLabelInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdInsertDebugUtilsLabelEXT\n"; } + device_dispatch_table(commandBuffer)->CmdInsertDebugUtilsLabelEXT(commandBuffer, pLabelInfo); } #if defined(VK_USE_PLATFORM_ANDROID_KHR) template VKAPI_ATTR VkResult VKAPI_CALL vkGetAndroidHardwareBufferPropertiesANDROID(VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetAndroidHardwareBufferPropertiesANDROID", "device, buffer, pProperties", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetAndroidHardwareBufferPropertiesANDROID(ApiDumpInstance::current(), device, buffer, pProperties); - } - } - VkResult result = device_dispatch_table(device)->GetAndroidHardwareBufferPropertiesANDROID(device, buffer, pProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetAndroidHardwareBufferPropertiesANDROID(ApiDumpInstance::current(), device, buffer, pProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetAndroidHardwareBufferPropertiesANDROID\n"; } + VkResult result = device_dispatch_table(device)->GetAndroidHardwareBufferPropertiesANDROID(device, buffer, pProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryAndroidHardwareBufferANDROID(VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetMemoryAndroidHardwareBufferANDROID", "device, pInfo, pBuffer", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetMemoryAndroidHardwareBufferANDROID(ApiDumpInstance::current(), device, pInfo, pBuffer); - } - } - VkResult result = device_dispatch_table(device)->GetMemoryAndroidHardwareBufferANDROID(device, pInfo, pBuffer); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetMemoryAndroidHardwareBufferANDROID(ApiDumpInstance::current(), device, pInfo, pBuffer); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetMemoryAndroidHardwareBufferANDROID\n"; } + VkResult result = device_dispatch_table(device)->GetMemoryAndroidHardwareBufferANDROID(device, pInfo, pBuffer); return result; } #endif // VK_USE_PLATFORM_ANDROID_KHR @@ -9509,1304 +4539,620 @@ template VKAPI_ATTR VkResult VKAPI_CALL vkCreateExecutionGraphPipelinesAMDX(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkExecutionGraphPipelineCreateInfoAMDX* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateExecutionGraphPipelinesAMDX", "device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateExecutionGraphPipelinesAMDX(ApiDumpInstance::current(), device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); - } - } - VkResult result = device_dispatch_table(device)->CreateExecutionGraphPipelinesAMDX(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateExecutionGraphPipelinesAMDX(ApiDumpInstance::current(), device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateExecutionGraphPipelinesAMDX\n"; } + VkResult result = device_dispatch_table(device)->CreateExecutionGraphPipelinesAMDX(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetExecutionGraphPipelineScratchSizeAMDX(VkDevice device, VkPipeline executionGraph, VkExecutionGraphPipelineScratchSizeAMDX* pSizeInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetExecutionGraphPipelineScratchSizeAMDX", "device, executionGraph, pSizeInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetExecutionGraphPipelineScratchSizeAMDX(ApiDumpInstance::current(), device, executionGraph, pSizeInfo); - } - } - VkResult result = device_dispatch_table(device)->GetExecutionGraphPipelineScratchSizeAMDX(device, executionGraph, pSizeInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetExecutionGraphPipelineScratchSizeAMDX(ApiDumpInstance::current(), device, executionGraph, pSizeInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetExecutionGraphPipelineScratchSizeAMDX\n"; } + VkResult result = device_dispatch_table(device)->GetExecutionGraphPipelineScratchSizeAMDX(device, executionGraph, pSizeInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetExecutionGraphPipelineNodeIndexAMDX(VkDevice device, VkPipeline executionGraph, const VkPipelineShaderStageNodeCreateInfoAMDX* pNodeInfo, uint32_t* pNodeIndex) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetExecutionGraphPipelineNodeIndexAMDX", "device, executionGraph, pNodeInfo, pNodeIndex", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetExecutionGraphPipelineNodeIndexAMDX(ApiDumpInstance::current(), device, executionGraph, pNodeInfo, pNodeIndex); - } - } - VkResult result = device_dispatch_table(device)->GetExecutionGraphPipelineNodeIndexAMDX(device, executionGraph, pNodeInfo, pNodeIndex); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetExecutionGraphPipelineNodeIndexAMDX(ApiDumpInstance::current(), device, executionGraph, pNodeInfo, pNodeIndex); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetExecutionGraphPipelineNodeIndexAMDX\n"; } + VkResult result = device_dispatch_table(device)->GetExecutionGraphPipelineNodeIndexAMDX(device, executionGraph, pNodeInfo, pNodeIndex); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdInitializeGraphScratchMemoryAMDX(VkCommandBuffer commandBuffer, VkPipeline executionGraph, VkDeviceAddress scratch, VkDeviceSize scratchSize) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdInitializeGraphScratchMemoryAMDX", "commandBuffer, executionGraph, scratch, scratchSize", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdInitializeGraphScratchMemoryAMDX(ApiDumpInstance::current(), commandBuffer, executionGraph, scratch, scratchSize); - } - } - device_dispatch_table(commandBuffer)->CmdInitializeGraphScratchMemoryAMDX(commandBuffer, executionGraph, scratch, scratchSize); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdInitializeGraphScratchMemoryAMDX(ApiDumpInstance::current(), commandBuffer, executionGraph, scratch, scratchSize); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdInitializeGraphScratchMemoryAMDX\n"; } + device_dispatch_table(commandBuffer)->CmdInitializeGraphScratchMemoryAMDX(commandBuffer, executionGraph, scratch, scratchSize); } template VKAPI_ATTR void VKAPI_CALL vkCmdDispatchGraphAMDX(VkCommandBuffer commandBuffer, VkDeviceAddress scratch, VkDeviceSize scratchSize, const VkDispatchGraphCountInfoAMDX* pCountInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdDispatchGraphAMDX", "commandBuffer, scratch, scratchSize, pCountInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDispatchGraphAMDX(ApiDumpInstance::current(), commandBuffer, scratch, scratchSize, pCountInfo); - } - } - device_dispatch_table(commandBuffer)->CmdDispatchGraphAMDX(commandBuffer, scratch, scratchSize, pCountInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDispatchGraphAMDX(ApiDumpInstance::current(), commandBuffer, scratch, scratchSize, pCountInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdDispatchGraphAMDX\n"; } + device_dispatch_table(commandBuffer)->CmdDispatchGraphAMDX(commandBuffer, scratch, scratchSize, pCountInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdDispatchGraphIndirectAMDX(VkCommandBuffer commandBuffer, VkDeviceAddress scratch, VkDeviceSize scratchSize, const VkDispatchGraphCountInfoAMDX* pCountInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdDispatchGraphIndirectAMDX", "commandBuffer, scratch, scratchSize, pCountInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDispatchGraphIndirectAMDX(ApiDumpInstance::current(), commandBuffer, scratch, scratchSize, pCountInfo); - } - } - device_dispatch_table(commandBuffer)->CmdDispatchGraphIndirectAMDX(commandBuffer, scratch, scratchSize, pCountInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDispatchGraphIndirectAMDX(ApiDumpInstance::current(), commandBuffer, scratch, scratchSize, pCountInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdDispatchGraphIndirectAMDX\n"; } + device_dispatch_table(commandBuffer)->CmdDispatchGraphIndirectAMDX(commandBuffer, scratch, scratchSize, pCountInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdDispatchGraphIndirectCountAMDX(VkCommandBuffer commandBuffer, VkDeviceAddress scratch, VkDeviceSize scratchSize, VkDeviceAddress countInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdDispatchGraphIndirectCountAMDX", "commandBuffer, scratch, scratchSize, countInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDispatchGraphIndirectCountAMDX(ApiDumpInstance::current(), commandBuffer, scratch, scratchSize, countInfo); - } - } - device_dispatch_table(commandBuffer)->CmdDispatchGraphIndirectCountAMDX(commandBuffer, scratch, scratchSize, countInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDispatchGraphIndirectCountAMDX(ApiDumpInstance::current(), commandBuffer, scratch, scratchSize, countInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdDispatchGraphIndirectCountAMDX\n"; } + device_dispatch_table(commandBuffer)->CmdDispatchGraphIndirectCountAMDX(commandBuffer, scratch, scratchSize, countInfo); } #endif // VK_ENABLE_BETA_EXTENSIONS template VKAPI_ATTR VkResult VKAPI_CALL vkWriteSamplerDescriptorsEXT(VkDevice device, uint32_t samplerCount, const VkSamplerCreateInfo* pSamplers, const VkHostAddressRangeEXT* pDescriptors) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkWriteSamplerDescriptorsEXT", "device, samplerCount, pSamplers, pDescriptors", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkWriteSamplerDescriptorsEXT(ApiDumpInstance::current(), device, samplerCount, pSamplers, pDescriptors); - } - } - VkResult result = device_dispatch_table(device)->WriteSamplerDescriptorsEXT(device, samplerCount, pSamplers, pDescriptors); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkWriteSamplerDescriptorsEXT(ApiDumpInstance::current(), device, samplerCount, pSamplers, pDescriptors); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkWriteSamplerDescriptorsEXT\n"; } + VkResult result = device_dispatch_table(device)->WriteSamplerDescriptorsEXT(device, samplerCount, pSamplers, pDescriptors); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkWriteResourceDescriptorsEXT(VkDevice device, uint32_t resourceCount, const VkResourceDescriptorInfoEXT* pResources, const VkHostAddressRangeEXT* pDescriptors) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkWriteResourceDescriptorsEXT", "device, resourceCount, pResources, pDescriptors", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkWriteResourceDescriptorsEXT(ApiDumpInstance::current(), device, resourceCount, pResources, pDescriptors); - } - } - VkResult result = device_dispatch_table(device)->WriteResourceDescriptorsEXT(device, resourceCount, pResources, pDescriptors); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkWriteResourceDescriptorsEXT(ApiDumpInstance::current(), device, resourceCount, pResources, pDescriptors); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkWriteResourceDescriptorsEXT\n"; } + VkResult result = device_dispatch_table(device)->WriteResourceDescriptorsEXT(device, resourceCount, pResources, pDescriptors); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdBindSamplerHeapEXT(VkCommandBuffer commandBuffer, const VkBindHeapInfoEXT* pBindInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBindSamplerHeapEXT", "commandBuffer, pBindInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBindSamplerHeapEXT(ApiDumpInstance::current(), commandBuffer, pBindInfo); - } - } - device_dispatch_table(commandBuffer)->CmdBindSamplerHeapEXT(commandBuffer, pBindInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBindSamplerHeapEXT(ApiDumpInstance::current(), commandBuffer, pBindInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBindSamplerHeapEXT\n"; } + device_dispatch_table(commandBuffer)->CmdBindSamplerHeapEXT(commandBuffer, pBindInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdBindResourceHeapEXT(VkCommandBuffer commandBuffer, const VkBindHeapInfoEXT* pBindInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBindResourceHeapEXT", "commandBuffer, pBindInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBindResourceHeapEXT(ApiDumpInstance::current(), commandBuffer, pBindInfo); - } - } - device_dispatch_table(commandBuffer)->CmdBindResourceHeapEXT(commandBuffer, pBindInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBindResourceHeapEXT(ApiDumpInstance::current(), commandBuffer, pBindInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBindResourceHeapEXT\n"; } + device_dispatch_table(commandBuffer)->CmdBindResourceHeapEXT(commandBuffer, pBindInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdPushDataEXT(VkCommandBuffer commandBuffer, const VkPushDataInfoEXT* pPushDataInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdPushDataEXT", "commandBuffer, pPushDataInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdPushDataEXT(ApiDumpInstance::current(), commandBuffer, pPushDataInfo); - } - } - device_dispatch_table(commandBuffer)->CmdPushDataEXT(commandBuffer, pPushDataInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdPushDataEXT(ApiDumpInstance::current(), commandBuffer, pPushDataInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdPushDataEXT\n"; } + device_dispatch_table(commandBuffer)->CmdPushDataEXT(commandBuffer, pPushDataInfo); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetImageOpaqueCaptureDataEXT(VkDevice device, uint32_t imageCount, const VkImage* pImages, VkHostAddressRangeEXT* pDatas) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetImageOpaqueCaptureDataEXT", "device, imageCount, pImages, pDatas", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetImageOpaqueCaptureDataEXT(ApiDumpInstance::current(), device, imageCount, pImages, pDatas); - } - } - VkResult result = device_dispatch_table(device)->GetImageOpaqueCaptureDataEXT(device, imageCount, pImages, pDatas); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetImageOpaqueCaptureDataEXT(ApiDumpInstance::current(), device, imageCount, pImages, pDatas); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetImageOpaqueCaptureDataEXT\n"; } + VkResult result = device_dispatch_table(device)->GetImageOpaqueCaptureDataEXT(device, imageCount, pImages, pDatas); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkRegisterCustomBorderColorEXT(VkDevice device, const VkSamplerCustomBorderColorCreateInfoEXT* pBorderColor, VkBool32 requestIndex, uint32_t* pIndex) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkRegisterCustomBorderColorEXT", "device, pBorderColor, requestIndex, pIndex", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkRegisterCustomBorderColorEXT(ApiDumpInstance::current(), device, pBorderColor, requestIndex, pIndex); - } - } - VkResult result = device_dispatch_table(device)->RegisterCustomBorderColorEXT(device, pBorderColor, requestIndex, pIndex); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkRegisterCustomBorderColorEXT(ApiDumpInstance::current(), device, pBorderColor, requestIndex, pIndex); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkRegisterCustomBorderColorEXT\n"; } + VkResult result = device_dispatch_table(device)->RegisterCustomBorderColorEXT(device, pBorderColor, requestIndex, pIndex); return result; } template VKAPI_ATTR void VKAPI_CALL vkUnregisterCustomBorderColorEXT(VkDevice device, uint32_t index) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkUnregisterCustomBorderColorEXT", "device, index", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkUnregisterCustomBorderColorEXT(ApiDumpInstance::current(), device, index); - } - } - device_dispatch_table(device)->UnregisterCustomBorderColorEXT(device, index); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkUnregisterCustomBorderColorEXT(ApiDumpInstance::current(), device, index); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkUnregisterCustomBorderColorEXT\n"; } + device_dispatch_table(device)->UnregisterCustomBorderColorEXT(device, index); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetTensorOpaqueCaptureDataARM(VkDevice device, uint32_t tensorCount, const VkTensorARM* pTensors, VkHostAddressRangeEXT* pDatas) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetTensorOpaqueCaptureDataARM", "device, tensorCount, pTensors, pDatas", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetTensorOpaqueCaptureDataARM(ApiDumpInstance::current(), device, tensorCount, pTensors, pDatas); - } - } - VkResult result = device_dispatch_table(device)->GetTensorOpaqueCaptureDataARM(device, tensorCount, pTensors, pDatas); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetTensorOpaqueCaptureDataARM(ApiDumpInstance::current(), device, tensorCount, pTensors, pDatas); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetTensorOpaqueCaptureDataARM\n"; } + VkResult result = device_dispatch_table(device)->GetTensorOpaqueCaptureDataARM(device, tensorCount, pTensors, pDatas); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetSampleLocationsEXT", "commandBuffer, pSampleLocationsInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetSampleLocationsEXT(ApiDumpInstance::current(), commandBuffer, pSampleLocationsInfo); - } - } - device_dispatch_table(commandBuffer)->CmdSetSampleLocationsEXT(commandBuffer, pSampleLocationsInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetSampleLocationsEXT(ApiDumpInstance::current(), commandBuffer, pSampleLocationsInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetSampleLocationsEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetSampleLocationsEXT(commandBuffer, pSampleLocationsInfo); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetImageDrmFormatModifierPropertiesEXT", "device, image, pProperties", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetImageDrmFormatModifierPropertiesEXT(ApiDumpInstance::current(), device, image, pProperties); - } - } - VkResult result = device_dispatch_table(device)->GetImageDrmFormatModifierPropertiesEXT(device, image, pProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetImageDrmFormatModifierPropertiesEXT(ApiDumpInstance::current(), device, image, pProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetImageDrmFormatModifierPropertiesEXT\n"; } + VkResult result = device_dispatch_table(device)->GetImageDrmFormatModifierPropertiesEXT(device, image, pProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateValidationCacheEXT(VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateValidationCacheEXT", "device, pCreateInfo, pAllocator, pValidationCache", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateValidationCacheEXT(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pValidationCache); - } - } - VkResult result = device_dispatch_table(device)->CreateValidationCacheEXT(device, pCreateInfo, pAllocator, pValidationCache); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateValidationCacheEXT(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pValidationCache); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateValidationCacheEXT\n"; } + VkResult result = device_dispatch_table(device)->CreateValidationCacheEXT(device, pCreateInfo, pAllocator, pValidationCache); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyValidationCacheEXT", "device, validationCache, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyValidationCacheEXT(ApiDumpInstance::current(), device, validationCache, pAllocator); - } - } - device_dispatch_table(device)->DestroyValidationCacheEXT(device, validationCache, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyValidationCacheEXT(ApiDumpInstance::current(), device, validationCache, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyValidationCacheEXT\n"; } + device_dispatch_table(device)->DestroyValidationCacheEXT(device, validationCache, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkMergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkMergeValidationCachesEXT", "device, dstCache, srcCacheCount, pSrcCaches", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkMergeValidationCachesEXT(ApiDumpInstance::current(), device, dstCache, srcCacheCount, pSrcCaches); - } - } - VkResult result = device_dispatch_table(device)->MergeValidationCachesEXT(device, dstCache, srcCacheCount, pSrcCaches); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkMergeValidationCachesEXT(ApiDumpInstance::current(), device, dstCache, srcCacheCount, pSrcCaches); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkMergeValidationCachesEXT\n"; } + VkResult result = device_dispatch_table(device)->MergeValidationCachesEXT(device, dstCache, srcCacheCount, pSrcCaches); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetValidationCacheDataEXT", "device, validationCache, pDataSize, pData", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetValidationCacheDataEXT(ApiDumpInstance::current(), device, validationCache, pDataSize, pData); - } - } - VkResult result = device_dispatch_table(device)->GetValidationCacheDataEXT(device, validationCache, pDataSize, pData); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetValidationCacheDataEXT(ApiDumpInstance::current(), device, validationCache, pDataSize, pData); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetValidationCacheDataEXT\n"; } + VkResult result = device_dispatch_table(device)->GetValidationCacheDataEXT(device, validationCache, pDataSize, pData); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBindShadingRateImageNV", "commandBuffer, imageView, imageLayout", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBindShadingRateImageNV(ApiDumpInstance::current(), commandBuffer, imageView, imageLayout); - } - } - device_dispatch_table(commandBuffer)->CmdBindShadingRateImageNV(commandBuffer, imageView, imageLayout); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBindShadingRateImageNV(ApiDumpInstance::current(), commandBuffer, imageView, imageLayout); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBindShadingRateImageNV\n"; } + device_dispatch_table(commandBuffer)->CmdBindShadingRateImageNV(commandBuffer, imageView, imageLayout); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetViewportShadingRatePaletteNV", "commandBuffer, firstViewport, viewportCount, pShadingRatePalettes", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetViewportShadingRatePaletteNV(ApiDumpInstance::current(), commandBuffer, firstViewport, viewportCount, pShadingRatePalettes); - } - } - device_dispatch_table(commandBuffer)->CmdSetViewportShadingRatePaletteNV(commandBuffer, firstViewport, viewportCount, pShadingRatePalettes); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetViewportShadingRatePaletteNV(ApiDumpInstance::current(), commandBuffer, firstViewport, viewportCount, pShadingRatePalettes); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetViewportShadingRatePaletteNV\n"; } + device_dispatch_table(commandBuffer)->CmdSetViewportShadingRatePaletteNV(commandBuffer, firstViewport, viewportCount, pShadingRatePalettes); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetCoarseSampleOrderNV", "commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetCoarseSampleOrderNV(ApiDumpInstance::current(), commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders); - } - } - device_dispatch_table(commandBuffer)->CmdSetCoarseSampleOrderNV(commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetCoarseSampleOrderNV(ApiDumpInstance::current(), commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetCoarseSampleOrderNV\n"; } + device_dispatch_table(commandBuffer)->CmdSetCoarseSampleOrderNV(commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateAccelerationStructureNV(VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateAccelerationStructureNV", "device, pCreateInfo, pAllocator, pAccelerationStructure", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateAccelerationStructureNV(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pAccelerationStructure); - } - } - VkResult result = device_dispatch_table(device)->CreateAccelerationStructureNV(device, pCreateInfo, pAllocator, pAccelerationStructure); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateAccelerationStructureNV(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pAccelerationStructure); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateAccelerationStructureNV\n"; } + VkResult result = device_dispatch_table(device)->CreateAccelerationStructureNV(device, pCreateInfo, pAllocator, pAccelerationStructure); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyAccelerationStructureNV", "device, accelerationStructure, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyAccelerationStructureNV(ApiDumpInstance::current(), device, accelerationStructure, pAllocator); - } - } - device_dispatch_table(device)->DestroyAccelerationStructureNV(device, accelerationStructure, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyAccelerationStructureNV(ApiDumpInstance::current(), device, accelerationStructure, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyAccelerationStructureNV\n"; } + device_dispatch_table(device)->DestroyAccelerationStructureNV(device, accelerationStructure, pAllocator); } template VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureMemoryRequirementsNV(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetAccelerationStructureMemoryRequirementsNV", "device, pInfo, pMemoryRequirements", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetAccelerationStructureMemoryRequirementsNV(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements); - } - } - device_dispatch_table(device)->GetAccelerationStructureMemoryRequirementsNV(device, pInfo, pMemoryRequirements); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetAccelerationStructureMemoryRequirementsNV(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetAccelerationStructureMemoryRequirementsNV\n"; } + device_dispatch_table(device)->GetAccelerationStructureMemoryRequirementsNV(device, pInfo, pMemoryRequirements); } template VKAPI_ATTR VkResult VKAPI_CALL vkBindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkBindAccelerationStructureMemoryNV", "device, bindInfoCount, pBindInfos", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkBindAccelerationStructureMemoryNV(ApiDumpInstance::current(), device, bindInfoCount, pBindInfos); - } - } - VkResult result = device_dispatch_table(device)->BindAccelerationStructureMemoryNV(device, bindInfoCount, pBindInfos); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkBindAccelerationStructureMemoryNV(ApiDumpInstance::current(), device, bindInfoCount, pBindInfos); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkBindAccelerationStructureMemoryNV\n"; } + VkResult result = device_dispatch_table(device)->BindAccelerationStructureMemoryNV(device, bindInfoCount, pBindInfos); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBuildAccelerationStructureNV", "commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBuildAccelerationStructureNV(ApiDumpInstance::current(), commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset); - } - } - device_dispatch_table(commandBuffer)->CmdBuildAccelerationStructureNV(commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBuildAccelerationStructureNV(ApiDumpInstance::current(), commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBuildAccelerationStructureNV\n"; } + device_dispatch_table(commandBuffer)->CmdBuildAccelerationStructureNV(commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset); } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdCopyAccelerationStructureNV", "commandBuffer, dst, src, mode", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyAccelerationStructureNV(ApiDumpInstance::current(), commandBuffer, dst, src, mode); - } - } - device_dispatch_table(commandBuffer)->CmdCopyAccelerationStructureNV(commandBuffer, dst, src, mode); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyAccelerationStructureNV(ApiDumpInstance::current(), commandBuffer, dst, src, mode); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdCopyAccelerationStructureNV\n"; } + device_dispatch_table(commandBuffer)->CmdCopyAccelerationStructureNV(commandBuffer, dst, src, mode); } template VKAPI_ATTR void VKAPI_CALL 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) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdTraceRaysNV", "commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdTraceRaysNV(ApiDumpInstance::current(), commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth); - } - } - device_dispatch_table(commandBuffer)->CmdTraceRaysNV(commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdTraceRaysNV(ApiDumpInstance::current(), commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdTraceRaysNV\n"; } + device_dispatch_table(commandBuffer)->CmdTraceRaysNV(commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateRayTracingPipelinesNV", "device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateRayTracingPipelinesNV(ApiDumpInstance::current(), device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); - } - } - VkResult result = device_dispatch_table(device)->CreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateRayTracingPipelinesNV(ApiDumpInstance::current(), device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateRayTracingPipelinesNV\n"; } + VkResult result = device_dispatch_table(device)->CreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetRayTracingShaderGroupHandlesKHR", "device, pipeline, firstGroup, groupCount, dataSize, pData", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetRayTracingShaderGroupHandlesKHR(ApiDumpInstance::current(), device, pipeline, firstGroup, groupCount, dataSize, pData); - } - } - VkResult result = device_dispatch_table(device)->GetRayTracingShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount, dataSize, pData); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetRayTracingShaderGroupHandlesKHR(ApiDumpInstance::current(), device, pipeline, firstGroup, groupCount, dataSize, pData); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetRayTracingShaderGroupHandlesKHR\n"; } + VkResult result = device_dispatch_table(device)->GetRayTracingShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount, dataSize, pData); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetRayTracingShaderGroupHandlesNV", "device, pipeline, firstGroup, groupCount, dataSize, pData", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetRayTracingShaderGroupHandlesNV(ApiDumpInstance::current(), device, pipeline, firstGroup, groupCount, dataSize, pData); - } - } - VkResult result = device_dispatch_table(device)->GetRayTracingShaderGroupHandlesNV(device, pipeline, firstGroup, groupCount, dataSize, pData); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetRayTracingShaderGroupHandlesNV(ApiDumpInstance::current(), device, pipeline, firstGroup, groupCount, dataSize, pData); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetRayTracingShaderGroupHandlesNV\n"; } + VkResult result = device_dispatch_table(device)->GetRayTracingShaderGroupHandlesNV(device, pipeline, firstGroup, groupCount, dataSize, pData); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetAccelerationStructureHandleNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetAccelerationStructureHandleNV", "device, accelerationStructure, dataSize, pData", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetAccelerationStructureHandleNV(ApiDumpInstance::current(), device, accelerationStructure, dataSize, pData); - } - } - VkResult result = device_dispatch_table(device)->GetAccelerationStructureHandleNV(device, accelerationStructure, dataSize, pData); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetAccelerationStructureHandleNV(ApiDumpInstance::current(), device, accelerationStructure, dataSize, pData); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetAccelerationStructureHandleNV\n"; } + VkResult result = device_dispatch_table(device)->GetAccelerationStructureHandleNV(device, accelerationStructure, dataSize, pData); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdWriteAccelerationStructuresPropertiesNV", "commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdWriteAccelerationStructuresPropertiesNV(ApiDumpInstance::current(), commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery); - } - } - device_dispatch_table(commandBuffer)->CmdWriteAccelerationStructuresPropertiesNV(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdWriteAccelerationStructuresPropertiesNV(ApiDumpInstance::current(), commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdWriteAccelerationStructuresPropertiesNV\n"; } + device_dispatch_table(commandBuffer)->CmdWriteAccelerationStructuresPropertiesNV(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery); } template VKAPI_ATTR VkResult VKAPI_CALL vkCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCompileDeferredNV", "device, pipeline, shader", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCompileDeferredNV(ApiDumpInstance::current(), device, pipeline, shader); - } - } - VkResult result = device_dispatch_table(device)->CompileDeferredNV(device, pipeline, shader); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCompileDeferredNV(ApiDumpInstance::current(), device, pipeline, shader); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCompileDeferredNV\n"; } + VkResult result = device_dispatch_table(device)->CompileDeferredNV(device, pipeline, shader); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetMemoryHostPointerPropertiesEXT", "device, handleType, pHostPointer, pMemoryHostPointerProperties", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetMemoryHostPointerPropertiesEXT(ApiDumpInstance::current(), device, handleType, pHostPointer, pMemoryHostPointerProperties); - } - } - VkResult result = device_dispatch_table(device)->GetMemoryHostPointerPropertiesEXT(device, handleType, pHostPointer, pMemoryHostPointerProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetMemoryHostPointerPropertiesEXT(ApiDumpInstance::current(), device, handleType, pHostPointer, pMemoryHostPointerProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetMemoryHostPointerPropertiesEXT\n"; } + VkResult result = device_dispatch_table(device)->GetMemoryHostPointerPropertiesEXT(device, handleType, pHostPointer, pMemoryHostPointerProperties); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdWriteBufferMarkerAMD", "commandBuffer, pipelineStage, dstBuffer, dstOffset, marker", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdWriteBufferMarkerAMD(ApiDumpInstance::current(), commandBuffer, pipelineStage, dstBuffer, dstOffset, marker); - } - } - device_dispatch_table(commandBuffer)->CmdWriteBufferMarkerAMD(commandBuffer, pipelineStage, dstBuffer, dstOffset, marker); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdWriteBufferMarkerAMD(ApiDumpInstance::current(), commandBuffer, pipelineStage, dstBuffer, dstOffset, marker); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdWriteBufferMarkerAMD\n"; } + device_dispatch_table(commandBuffer)->CmdWriteBufferMarkerAMD(commandBuffer, pipelineStage, dstBuffer, dstOffset, marker); } template VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdWriteBufferMarker2AMD", "commandBuffer, stage, dstBuffer, dstOffset, marker", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdWriteBufferMarker2AMD(ApiDumpInstance::current(), commandBuffer, stage, dstBuffer, dstOffset, marker); - } - } - device_dispatch_table(commandBuffer)->CmdWriteBufferMarker2AMD(commandBuffer, stage, dstBuffer, dstOffset, marker); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdWriteBufferMarker2AMD(ApiDumpInstance::current(), commandBuffer, stage, dstBuffer, dstOffset, marker); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdWriteBufferMarker2AMD\n"; } + device_dispatch_table(commandBuffer)->CmdWriteBufferMarker2AMD(commandBuffer, stage, dstBuffer, dstOffset, marker); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetCalibratedTimestampsEXT", "device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetCalibratedTimestampsEXT(ApiDumpInstance::current(), device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation); - } - } - VkResult result = device_dispatch_table(device)->GetCalibratedTimestampsEXT(device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetCalibratedTimestampsEXT(ApiDumpInstance::current(), device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetCalibratedTimestampsEXT\n"; } + VkResult result = device_dispatch_table(device)->GetCalibratedTimestampsEXT(device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdDrawMeshTasksNV", "commandBuffer, taskCount, firstTask", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDrawMeshTasksNV(ApiDumpInstance::current(), commandBuffer, taskCount, firstTask); - } - } - device_dispatch_table(commandBuffer)->CmdDrawMeshTasksNV(commandBuffer, taskCount, firstTask); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDrawMeshTasksNV(ApiDumpInstance::current(), commandBuffer, taskCount, firstTask); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdDrawMeshTasksNV\n"; } + device_dispatch_table(commandBuffer)->CmdDrawMeshTasksNV(commandBuffer, taskCount, firstTask); } template VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdDrawMeshTasksIndirectNV", "commandBuffer, buffer, offset, drawCount, stride", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDrawMeshTasksIndirectNV(ApiDumpInstance::current(), commandBuffer, buffer, offset, drawCount, stride); - } - } - device_dispatch_table(commandBuffer)->CmdDrawMeshTasksIndirectNV(commandBuffer, buffer, offset, drawCount, stride); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDrawMeshTasksIndirectNV(ApiDumpInstance::current(), commandBuffer, buffer, offset, drawCount, stride); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdDrawMeshTasksIndirectNV\n"; } + device_dispatch_table(commandBuffer)->CmdDrawMeshTasksIndirectNV(commandBuffer, buffer, offset, drawCount, stride); } template VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdDrawMeshTasksIndirectCountNV", "commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDrawMeshTasksIndirectCountNV(ApiDumpInstance::current(), commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); - } - } - device_dispatch_table(commandBuffer)->CmdDrawMeshTasksIndirectCountNV(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDrawMeshTasksIndirectCountNV(ApiDumpInstance::current(), commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdDrawMeshTasksIndirectCountNV\n"; } + device_dispatch_table(commandBuffer)->CmdDrawMeshTasksIndirectCountNV(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetExclusiveScissorEnableNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkBool32* pExclusiveScissorEnables) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetExclusiveScissorEnableNV", "commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissorEnables", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetExclusiveScissorEnableNV(ApiDumpInstance::current(), commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissorEnables); - } - } - device_dispatch_table(commandBuffer)->CmdSetExclusiveScissorEnableNV(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissorEnables); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetExclusiveScissorEnableNV(ApiDumpInstance::current(), commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissorEnables); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetExclusiveScissorEnableNV\n"; } + device_dispatch_table(commandBuffer)->CmdSetExclusiveScissorEnableNV(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissorEnables); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetExclusiveScissorNV", "commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetExclusiveScissorNV(ApiDumpInstance::current(), commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors); - } - } - device_dispatch_table(commandBuffer)->CmdSetExclusiveScissorNV(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetExclusiveScissorNV(ApiDumpInstance::current(), commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetExclusiveScissorNV\n"; } + device_dispatch_table(commandBuffer)->CmdSetExclusiveScissorNV(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void* pCheckpointMarker) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetCheckpointNV", "commandBuffer, pCheckpointMarker", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetCheckpointNV(ApiDumpInstance::current(), commandBuffer, pCheckpointMarker); - } - } - device_dispatch_table(commandBuffer)->CmdSetCheckpointNV(commandBuffer, pCheckpointMarker); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetCheckpointNV(ApiDumpInstance::current(), commandBuffer, pCheckpointMarker); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetCheckpointNV\n"; } + device_dispatch_table(commandBuffer)->CmdSetCheckpointNV(commandBuffer, pCheckpointMarker); } template VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointDataNV(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetQueueCheckpointDataNV", "queue, pCheckpointDataCount, pCheckpointData", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetQueueCheckpointDataNV(ApiDumpInstance::current(), queue, pCheckpointDataCount, pCheckpointData); - } - } - device_dispatch_table(queue)->GetQueueCheckpointDataNV(queue, pCheckpointDataCount, pCheckpointData); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetQueueCheckpointDataNV(ApiDumpInstance::current(), queue, pCheckpointDataCount, pCheckpointData); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetQueueCheckpointDataNV\n"; } + device_dispatch_table(queue)->GetQueueCheckpointDataNV(queue, pCheckpointDataCount, pCheckpointData); } template VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointData2NV(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetQueueCheckpointData2NV", "queue, pCheckpointDataCount, pCheckpointData", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetQueueCheckpointData2NV(ApiDumpInstance::current(), queue, pCheckpointDataCount, pCheckpointData); - } - } - device_dispatch_table(queue)->GetQueueCheckpointData2NV(queue, pCheckpointDataCount, pCheckpointData); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetQueueCheckpointData2NV(ApiDumpInstance::current(), queue, pCheckpointDataCount, pCheckpointData); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetQueueCheckpointData2NV\n"; } + device_dispatch_table(queue)->GetQueueCheckpointData2NV(queue, pCheckpointDataCount, pCheckpointData); } template VKAPI_ATTR VkResult VKAPI_CALL vkSetSwapchainPresentTimingQueueSizeEXT(VkDevice device, VkSwapchainKHR swapchain, uint32_t size) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkSetSwapchainPresentTimingQueueSizeEXT", "device, swapchain, size", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkSetSwapchainPresentTimingQueueSizeEXT(ApiDumpInstance::current(), device, swapchain, size); - } - } - VkResult result = device_dispatch_table(device)->SetSwapchainPresentTimingQueueSizeEXT(device, swapchain, size); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkSetSwapchainPresentTimingQueueSizeEXT(ApiDumpInstance::current(), device, swapchain, size); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkSetSwapchainPresentTimingQueueSizeEXT\n"; } + VkResult result = device_dispatch_table(device)->SetSwapchainPresentTimingQueueSizeEXT(device, swapchain, size); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainTimingPropertiesEXT(VkDevice device, VkSwapchainKHR swapchain, VkSwapchainTimingPropertiesEXT* pSwapchainTimingProperties, uint64_t* pSwapchainTimingPropertiesCounter) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetSwapchainTimingPropertiesEXT", "device, swapchain, pSwapchainTimingProperties, pSwapchainTimingPropertiesCounter", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetSwapchainTimingPropertiesEXT(ApiDumpInstance::current(), device, swapchain, pSwapchainTimingProperties, pSwapchainTimingPropertiesCounter); - } - } - VkResult result = device_dispatch_table(device)->GetSwapchainTimingPropertiesEXT(device, swapchain, pSwapchainTimingProperties, pSwapchainTimingPropertiesCounter); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetSwapchainTimingPropertiesEXT(ApiDumpInstance::current(), device, swapchain, pSwapchainTimingProperties, pSwapchainTimingPropertiesCounter); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetSwapchainTimingPropertiesEXT\n"; } + VkResult result = device_dispatch_table(device)->GetSwapchainTimingPropertiesEXT(device, swapchain, pSwapchainTimingProperties, pSwapchainTimingPropertiesCounter); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainTimeDomainPropertiesEXT(VkDevice device, VkSwapchainKHR swapchain, VkSwapchainTimeDomainPropertiesEXT* pSwapchainTimeDomainProperties, uint64_t* pTimeDomainsCounter) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetSwapchainTimeDomainPropertiesEXT", "device, swapchain, pSwapchainTimeDomainProperties, pTimeDomainsCounter", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetSwapchainTimeDomainPropertiesEXT(ApiDumpInstance::current(), device, swapchain, pSwapchainTimeDomainProperties, pTimeDomainsCounter); - } - } - VkResult result = device_dispatch_table(device)->GetSwapchainTimeDomainPropertiesEXT(device, swapchain, pSwapchainTimeDomainProperties, pTimeDomainsCounter); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetSwapchainTimeDomainPropertiesEXT(ApiDumpInstance::current(), device, swapchain, pSwapchainTimeDomainProperties, pTimeDomainsCounter); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetSwapchainTimeDomainPropertiesEXT\n"; } + VkResult result = device_dispatch_table(device)->GetSwapchainTimeDomainPropertiesEXT(device, swapchain, pSwapchainTimeDomainProperties, pTimeDomainsCounter); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPastPresentationTimingEXT(VkDevice device, const VkPastPresentationTimingInfoEXT* pPastPresentationTimingInfo, VkPastPresentationTimingPropertiesEXT* pPastPresentationTimingProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPastPresentationTimingEXT", "device, pPastPresentationTimingInfo, pPastPresentationTimingProperties", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPastPresentationTimingEXT(ApiDumpInstance::current(), device, pPastPresentationTimingInfo, pPastPresentationTimingProperties); - } - } - VkResult result = device_dispatch_table(device)->GetPastPresentationTimingEXT(device, pPastPresentationTimingInfo, pPastPresentationTimingProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPastPresentationTimingEXT(ApiDumpInstance::current(), device, pPastPresentationTimingInfo, pPastPresentationTimingProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPastPresentationTimingEXT\n"; } + VkResult result = device_dispatch_table(device)->GetPastPresentationTimingEXT(device, pPastPresentationTimingInfo, pPastPresentationTimingProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkInitializePerformanceApiINTEL(VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkInitializePerformanceApiINTEL", "device, pInitializeInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkInitializePerformanceApiINTEL(ApiDumpInstance::current(), device, pInitializeInfo); - } - } - VkResult result = device_dispatch_table(device)->InitializePerformanceApiINTEL(device, pInitializeInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkInitializePerformanceApiINTEL(ApiDumpInstance::current(), device, pInitializeInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkInitializePerformanceApiINTEL\n"; } + VkResult result = device_dispatch_table(device)->InitializePerformanceApiINTEL(device, pInitializeInfo); return result; } template VKAPI_ATTR void VKAPI_CALL vkUninitializePerformanceApiINTEL(VkDevice device) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkUninitializePerformanceApiINTEL", "device", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkUninitializePerformanceApiINTEL(ApiDumpInstance::current(), device); - } - } - device_dispatch_table(device)->UninitializePerformanceApiINTEL(device); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkUninitializePerformanceApiINTEL(ApiDumpInstance::current(), device); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkUninitializePerformanceApiINTEL\n"; } + device_dispatch_table(device)->UninitializePerformanceApiINTEL(device); } template VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetPerformanceMarkerINTEL", "commandBuffer, pMarkerInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetPerformanceMarkerINTEL(ApiDumpInstance::current(), commandBuffer, pMarkerInfo); - } - } - VkResult result = device_dispatch_table(commandBuffer)->CmdSetPerformanceMarkerINTEL(commandBuffer, pMarkerInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetPerformanceMarkerINTEL(ApiDumpInstance::current(), commandBuffer, pMarkerInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetPerformanceMarkerINTEL\n"; } + VkResult result = device_dispatch_table(commandBuffer)->CmdSetPerformanceMarkerINTEL(commandBuffer, pMarkerInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetPerformanceStreamMarkerINTEL", "commandBuffer, pMarkerInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetPerformanceStreamMarkerINTEL(ApiDumpInstance::current(), commandBuffer, pMarkerInfo); - } - } - VkResult result = device_dispatch_table(commandBuffer)->CmdSetPerformanceStreamMarkerINTEL(commandBuffer, pMarkerInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetPerformanceStreamMarkerINTEL(ApiDumpInstance::current(), commandBuffer, pMarkerInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetPerformanceStreamMarkerINTEL\n"; } + VkResult result = device_dispatch_table(commandBuffer)->CmdSetPerformanceStreamMarkerINTEL(commandBuffer, pMarkerInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetPerformanceOverrideINTEL", "commandBuffer, pOverrideInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetPerformanceOverrideINTEL(ApiDumpInstance::current(), commandBuffer, pOverrideInfo); - } - } - VkResult result = device_dispatch_table(commandBuffer)->CmdSetPerformanceOverrideINTEL(commandBuffer, pOverrideInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetPerformanceOverrideINTEL(ApiDumpInstance::current(), commandBuffer, pOverrideInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetPerformanceOverrideINTEL\n"; } + VkResult result = device_dispatch_table(commandBuffer)->CmdSetPerformanceOverrideINTEL(commandBuffer, pOverrideInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkAcquirePerformanceConfigurationINTEL(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkAcquirePerformanceConfigurationINTEL", "device, pAcquireInfo, pConfiguration", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkAcquirePerformanceConfigurationINTEL(ApiDumpInstance::current(), device, pAcquireInfo, pConfiguration); - } - } - VkResult result = device_dispatch_table(device)->AcquirePerformanceConfigurationINTEL(device, pAcquireInfo, pConfiguration); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkAcquirePerformanceConfigurationINTEL(ApiDumpInstance::current(), device, pAcquireInfo, pConfiguration); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkAcquirePerformanceConfigurationINTEL\n"; } + VkResult result = device_dispatch_table(device)->AcquirePerformanceConfigurationINTEL(device, pAcquireInfo, pConfiguration); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkReleasePerformanceConfigurationINTEL(VkDevice device, VkPerformanceConfigurationINTEL configuration) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkReleasePerformanceConfigurationINTEL", "device, configuration", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkReleasePerformanceConfigurationINTEL(ApiDumpInstance::current(), device, configuration); - } - } - VkResult result = device_dispatch_table(device)->ReleasePerformanceConfigurationINTEL(device, configuration); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkReleasePerformanceConfigurationINTEL(ApiDumpInstance::current(), device, configuration); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkReleasePerformanceConfigurationINTEL\n"; } + VkResult result = device_dispatch_table(device)->ReleasePerformanceConfigurationINTEL(device, configuration); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkQueueSetPerformanceConfigurationINTEL(VkQueue queue, VkPerformanceConfigurationINTEL configuration) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkQueueSetPerformanceConfigurationINTEL", "queue, configuration", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkQueueSetPerformanceConfigurationINTEL(ApiDumpInstance::current(), queue, configuration); - } - } - VkResult result = device_dispatch_table(queue)->QueueSetPerformanceConfigurationINTEL(queue, configuration); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkQueueSetPerformanceConfigurationINTEL(ApiDumpInstance::current(), queue, configuration); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkQueueSetPerformanceConfigurationINTEL\n"; } + VkResult result = device_dispatch_table(queue)->QueueSetPerformanceConfigurationINTEL(queue, configuration); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPerformanceParameterINTEL", "device, parameter, pValue", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPerformanceParameterINTEL(ApiDumpInstance::current(), device, parameter, pValue); - } - } - VkResult result = device_dispatch_table(device)->GetPerformanceParameterINTEL(device, parameter, pValue); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPerformanceParameterINTEL(ApiDumpInstance::current(), device, parameter, pValue); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPerformanceParameterINTEL\n"; } + VkResult result = device_dispatch_table(device)->GetPerformanceParameterINTEL(device, parameter, pValue); return result; } template VKAPI_ATTR void VKAPI_CALL vkSetLocalDimmingAMD(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkSetLocalDimmingAMD", "device, swapChain, localDimmingEnable", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkSetLocalDimmingAMD(ApiDumpInstance::current(), device, swapChain, localDimmingEnable); - } - } - device_dispatch_table(device)->SetLocalDimmingAMD(device, swapChain, localDimmingEnable); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkSetLocalDimmingAMD(ApiDumpInstance::current(), device, swapChain, localDimmingEnable); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkSetLocalDimmingAMD\n"; } + device_dispatch_table(device)->SetLocalDimmingAMD(device, swapChain, localDimmingEnable); } template VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressEXT(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetBufferDeviceAddressEXT", "device, pInfo", "VkDeviceAddress"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetBufferDeviceAddressEXT(ApiDumpInstance::current(), device, pInfo); - } - } - VkDeviceAddress result = device_dispatch_table(device)->GetBufferDeviceAddressEXT(device, pInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkDeviceAddress", result, dump_return_value_VkDeviceAddress); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetBufferDeviceAddressEXT(ApiDumpInstance::current(), device, pInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetBufferDeviceAddressEXT\n"; } + VkDeviceAddress result = device_dispatch_table(device)->GetBufferDeviceAddressEXT(device, pInfo); return result; } #if defined(VK_USE_PLATFORM_WIN32_KHR) @@ -10814,63 +5160,30 @@ template VKAPI_ATTR VkResult VKAPI_CALL vkAcquireFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkAcquireFullScreenExclusiveModeEXT", "device, swapchain", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkAcquireFullScreenExclusiveModeEXT(ApiDumpInstance::current(), device, swapchain); - } - } - VkResult result = device_dispatch_table(device)->AcquireFullScreenExclusiveModeEXT(device, swapchain); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkAcquireFullScreenExclusiveModeEXT(ApiDumpInstance::current(), device, swapchain); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkAcquireFullScreenExclusiveModeEXT\n"; } + VkResult result = device_dispatch_table(device)->AcquireFullScreenExclusiveModeEXT(device, swapchain); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkReleaseFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkReleaseFullScreenExclusiveModeEXT", "device, swapchain", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkReleaseFullScreenExclusiveModeEXT(ApiDumpInstance::current(), device, swapchain); - } - } - VkResult result = device_dispatch_table(device)->ReleaseFullScreenExclusiveModeEXT(device, swapchain); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkReleaseFullScreenExclusiveModeEXT(ApiDumpInstance::current(), device, swapchain); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkReleaseFullScreenExclusiveModeEXT\n"; } + VkResult result = device_dispatch_table(device)->ReleaseFullScreenExclusiveModeEXT(device, swapchain); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModes2EXT(VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDeviceGroupSurfacePresentModes2EXT", "device, pSurfaceInfo, pModes", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceGroupSurfacePresentModes2EXT(ApiDumpInstance::current(), device, pSurfaceInfo, pModes); - } - } - VkResult result = device_dispatch_table(device)->GetDeviceGroupSurfacePresentModes2EXT(device, pSurfaceInfo, pModes); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceGroupSurfacePresentModes2EXT(ApiDumpInstance::current(), device, pSurfaceInfo, pModes); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDeviceGroupSurfacePresentModes2EXT\n"; } + VkResult result = device_dispatch_table(device)->GetDeviceGroupSurfacePresentModes2EXT(device, pSurfaceInfo, pModes); return result; } #endif // VK_USE_PLATFORM_WIN32_KHR @@ -10878,1271 +5191,606 @@ template VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetLineStippleEXT", "commandBuffer, lineStippleFactor, lineStipplePattern", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetLineStippleEXT(ApiDumpInstance::current(), commandBuffer, lineStippleFactor, lineStipplePattern); - } - } - device_dispatch_table(commandBuffer)->CmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetLineStippleEXT(ApiDumpInstance::current(), commandBuffer, lineStippleFactor, lineStipplePattern); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetLineStippleEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern); } template VKAPI_ATTR void VKAPI_CALL vkResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkResetQueryPoolEXT", "device, queryPool, firstQuery, queryCount", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkResetQueryPoolEXT(ApiDumpInstance::current(), device, queryPool, firstQuery, queryCount); - } - } - device_dispatch_table(device)->ResetQueryPoolEXT(device, queryPool, firstQuery, queryCount); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkResetQueryPoolEXT(ApiDumpInstance::current(), device, queryPool, firstQuery, queryCount); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkResetQueryPoolEXT\n"; } + device_dispatch_table(device)->ResetQueryPoolEXT(device, queryPool, firstQuery, queryCount); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetCullModeEXT", "commandBuffer, cullMode", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetCullModeEXT(ApiDumpInstance::current(), commandBuffer, cullMode); - } - } - device_dispatch_table(commandBuffer)->CmdSetCullModeEXT(commandBuffer, cullMode); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetCullModeEXT(ApiDumpInstance::current(), commandBuffer, cullMode); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetCullModeEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetCullModeEXT(commandBuffer, cullMode); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetFrontFaceEXT", "commandBuffer, frontFace", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetFrontFaceEXT(ApiDumpInstance::current(), commandBuffer, frontFace); - } - } - device_dispatch_table(commandBuffer)->CmdSetFrontFaceEXT(commandBuffer, frontFace); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetFrontFaceEXT(ApiDumpInstance::current(), commandBuffer, frontFace); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetFrontFaceEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetFrontFaceEXT(commandBuffer, frontFace); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetPrimitiveTopologyEXT", "commandBuffer, primitiveTopology", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetPrimitiveTopologyEXT(ApiDumpInstance::current(), commandBuffer, primitiveTopology); - } - } - device_dispatch_table(commandBuffer)->CmdSetPrimitiveTopologyEXT(commandBuffer, primitiveTopology); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetPrimitiveTopologyEXT(ApiDumpInstance::current(), commandBuffer, primitiveTopology); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetPrimitiveTopologyEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetPrimitiveTopologyEXT(commandBuffer, primitiveTopology); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetViewportWithCountEXT", "commandBuffer, viewportCount, pViewports", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetViewportWithCountEXT(ApiDumpInstance::current(), commandBuffer, viewportCount, pViewports); - } - } - device_dispatch_table(commandBuffer)->CmdSetViewportWithCountEXT(commandBuffer, viewportCount, pViewports); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetViewportWithCountEXT(ApiDumpInstance::current(), commandBuffer, viewportCount, pViewports); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetViewportWithCountEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetViewportWithCountEXT(commandBuffer, viewportCount, pViewports); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetScissorWithCountEXT", "commandBuffer, scissorCount, pScissors", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetScissorWithCountEXT(ApiDumpInstance::current(), commandBuffer, scissorCount, pScissors); - } - } - device_dispatch_table(commandBuffer)->CmdSetScissorWithCountEXT(commandBuffer, scissorCount, pScissors); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetScissorWithCountEXT(ApiDumpInstance::current(), commandBuffer, scissorCount, pScissors); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetScissorWithCountEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetScissorWithCountEXT(commandBuffer, scissorCount, pScissors); } template VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBindVertexBuffers2EXT", "commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBindVertexBuffers2EXT(ApiDumpInstance::current(), commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides); - } - } - device_dispatch_table(commandBuffer)->CmdBindVertexBuffers2EXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBindVertexBuffers2EXT(ApiDumpInstance::current(), commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBindVertexBuffers2EXT\n"; } + device_dispatch_table(commandBuffer)->CmdBindVertexBuffers2EXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetDepthTestEnableEXT", "commandBuffer, depthTestEnable", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDepthTestEnableEXT(ApiDumpInstance::current(), commandBuffer, depthTestEnable); - } - } - device_dispatch_table(commandBuffer)->CmdSetDepthTestEnableEXT(commandBuffer, depthTestEnable); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDepthTestEnableEXT(ApiDumpInstance::current(), commandBuffer, depthTestEnable); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetDepthTestEnableEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetDepthTestEnableEXT(commandBuffer, depthTestEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetDepthWriteEnableEXT", "commandBuffer, depthWriteEnable", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDepthWriteEnableEXT(ApiDumpInstance::current(), commandBuffer, depthWriteEnable); - } - } - device_dispatch_table(commandBuffer)->CmdSetDepthWriteEnableEXT(commandBuffer, depthWriteEnable); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDepthWriteEnableEXT(ApiDumpInstance::current(), commandBuffer, depthWriteEnable); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetDepthWriteEnableEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetDepthWriteEnableEXT(commandBuffer, depthWriteEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetDepthCompareOpEXT", "commandBuffer, depthCompareOp", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDepthCompareOpEXT(ApiDumpInstance::current(), commandBuffer, depthCompareOp); - } - } - device_dispatch_table(commandBuffer)->CmdSetDepthCompareOpEXT(commandBuffer, depthCompareOp); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDepthCompareOpEXT(ApiDumpInstance::current(), commandBuffer, depthCompareOp); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetDepthCompareOpEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetDepthCompareOpEXT(commandBuffer, depthCompareOp); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetDepthBoundsTestEnableEXT", "commandBuffer, depthBoundsTestEnable", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDepthBoundsTestEnableEXT(ApiDumpInstance::current(), commandBuffer, depthBoundsTestEnable); - } - } - device_dispatch_table(commandBuffer)->CmdSetDepthBoundsTestEnableEXT(commandBuffer, depthBoundsTestEnable); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDepthBoundsTestEnableEXT(ApiDumpInstance::current(), commandBuffer, depthBoundsTestEnable); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetDepthBoundsTestEnableEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetDepthBoundsTestEnableEXT(commandBuffer, depthBoundsTestEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetStencilTestEnableEXT", "commandBuffer, stencilTestEnable", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetStencilTestEnableEXT(ApiDumpInstance::current(), commandBuffer, stencilTestEnable); - } - } - device_dispatch_table(commandBuffer)->CmdSetStencilTestEnableEXT(commandBuffer, stencilTestEnable); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetStencilTestEnableEXT(ApiDumpInstance::current(), commandBuffer, stencilTestEnable); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetStencilTestEnableEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetStencilTestEnableEXT(commandBuffer, stencilTestEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilOpEXT(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetStencilOpEXT", "commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetStencilOpEXT(ApiDumpInstance::current(), commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp); - } - } - device_dispatch_table(commandBuffer)->CmdSetStencilOpEXT(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetStencilOpEXT(ApiDumpInstance::current(), commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetStencilOpEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetStencilOpEXT(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp); } template VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToImageEXT(VkDevice device, const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCopyMemoryToImageEXT", "device, pCopyMemoryToImageInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCopyMemoryToImageEXT(ApiDumpInstance::current(), device, pCopyMemoryToImageInfo); - } - } - VkResult result = device_dispatch_table(device)->CopyMemoryToImageEXT(device, pCopyMemoryToImageInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCopyMemoryToImageEXT(ApiDumpInstance::current(), device, pCopyMemoryToImageInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCopyMemoryToImageEXT\n"; } + VkResult result = device_dispatch_table(device)->CopyMemoryToImageEXT(device, pCopyMemoryToImageInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCopyImageToMemoryEXT(VkDevice device, const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCopyImageToMemoryEXT", "device, pCopyImageToMemoryInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCopyImageToMemoryEXT(ApiDumpInstance::current(), device, pCopyImageToMemoryInfo); - } - } - VkResult result = device_dispatch_table(device)->CopyImageToMemoryEXT(device, pCopyImageToMemoryInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCopyImageToMemoryEXT(ApiDumpInstance::current(), device, pCopyImageToMemoryInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCopyImageToMemoryEXT\n"; } + VkResult result = device_dispatch_table(device)->CopyImageToMemoryEXT(device, pCopyImageToMemoryInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCopyImageToImageEXT(VkDevice device, const VkCopyImageToImageInfo* pCopyImageToImageInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCopyImageToImageEXT", "device, pCopyImageToImageInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCopyImageToImageEXT(ApiDumpInstance::current(), device, pCopyImageToImageInfo); - } - } - VkResult result = device_dispatch_table(device)->CopyImageToImageEXT(device, pCopyImageToImageInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCopyImageToImageEXT(ApiDumpInstance::current(), device, pCopyImageToImageInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCopyImageToImageEXT\n"; } + VkResult result = device_dispatch_table(device)->CopyImageToImageEXT(device, pCopyImageToImageInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkTransitionImageLayoutEXT(VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfo* pTransitions) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkTransitionImageLayoutEXT", "device, transitionCount, pTransitions", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkTransitionImageLayoutEXT(ApiDumpInstance::current(), device, transitionCount, pTransitions); - } - } - VkResult result = device_dispatch_table(device)->TransitionImageLayoutEXT(device, transitionCount, pTransitions); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkTransitionImageLayoutEXT(ApiDumpInstance::current(), device, transitionCount, pTransitions); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkTransitionImageLayoutEXT\n"; } + VkResult result = device_dispatch_table(device)->TransitionImageLayoutEXT(device, transitionCount, pTransitions); return result; } template VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout2EXT(VkDevice device, VkImage image, const VkImageSubresource2* pSubresource, VkSubresourceLayout2* pLayout) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetImageSubresourceLayout2EXT", "device, image, pSubresource, pLayout", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetImageSubresourceLayout2EXT(ApiDumpInstance::current(), device, image, pSubresource, pLayout); - } - } - device_dispatch_table(device)->GetImageSubresourceLayout2EXT(device, image, pSubresource, pLayout); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetImageSubresourceLayout2EXT(ApiDumpInstance::current(), device, image, pSubresource, pLayout); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetImageSubresourceLayout2EXT\n"; } + device_dispatch_table(device)->GetImageSubresourceLayout2EXT(device, image, pSubresource, pLayout); } template VKAPI_ATTR VkResult VKAPI_CALL vkReleaseSwapchainImagesEXT(VkDevice device, const VkReleaseSwapchainImagesInfoKHR* pReleaseInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkReleaseSwapchainImagesEXT", "device, pReleaseInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkReleaseSwapchainImagesEXT(ApiDumpInstance::current(), device, pReleaseInfo); - } - } - VkResult result = device_dispatch_table(device)->ReleaseSwapchainImagesEXT(device, pReleaseInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkReleaseSwapchainImagesEXT(ApiDumpInstance::current(), device, pReleaseInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkReleaseSwapchainImagesEXT\n"; } + VkResult result = device_dispatch_table(device)->ReleaseSwapchainImagesEXT(device, pReleaseInfo); return result; } template VKAPI_ATTR void VKAPI_CALL vkGetGeneratedCommandsMemoryRequirementsNV(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2* pMemoryRequirements) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetGeneratedCommandsMemoryRequirementsNV", "device, pInfo, pMemoryRequirements", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetGeneratedCommandsMemoryRequirementsNV(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements); - } - } - device_dispatch_table(device)->GetGeneratedCommandsMemoryRequirementsNV(device, pInfo, pMemoryRequirements); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetGeneratedCommandsMemoryRequirementsNV(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetGeneratedCommandsMemoryRequirementsNV\n"; } + device_dispatch_table(device)->GetGeneratedCommandsMemoryRequirementsNV(device, pInfo, pMemoryRequirements); } template VKAPI_ATTR void VKAPI_CALL vkCmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdPreprocessGeneratedCommandsNV", "commandBuffer, pGeneratedCommandsInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdPreprocessGeneratedCommandsNV(ApiDumpInstance::current(), commandBuffer, pGeneratedCommandsInfo); - } - } - device_dispatch_table(commandBuffer)->CmdPreprocessGeneratedCommandsNV(commandBuffer, pGeneratedCommandsInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdPreprocessGeneratedCommandsNV(ApiDumpInstance::current(), commandBuffer, pGeneratedCommandsInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdPreprocessGeneratedCommandsNV\n"; } + device_dispatch_table(commandBuffer)->CmdPreprocessGeneratedCommandsNV(commandBuffer, pGeneratedCommandsInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdExecuteGeneratedCommandsNV", "commandBuffer, isPreprocessed, pGeneratedCommandsInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdExecuteGeneratedCommandsNV(ApiDumpInstance::current(), commandBuffer, isPreprocessed, pGeneratedCommandsInfo); - } - } - device_dispatch_table(commandBuffer)->CmdExecuteGeneratedCommandsNV(commandBuffer, isPreprocessed, pGeneratedCommandsInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdExecuteGeneratedCommandsNV(ApiDumpInstance::current(), commandBuffer, isPreprocessed, pGeneratedCommandsInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdExecuteGeneratedCommandsNV\n"; } + device_dispatch_table(commandBuffer)->CmdExecuteGeneratedCommandsNV(commandBuffer, isPreprocessed, pGeneratedCommandsInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBindPipelineShaderGroupNV", "commandBuffer, pipelineBindPoint, pipeline, groupIndex", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBindPipelineShaderGroupNV(ApiDumpInstance::current(), commandBuffer, pipelineBindPoint, pipeline, groupIndex); - } - } - device_dispatch_table(commandBuffer)->CmdBindPipelineShaderGroupNV(commandBuffer, pipelineBindPoint, pipeline, groupIndex); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBindPipelineShaderGroupNV(ApiDumpInstance::current(), commandBuffer, pipelineBindPoint, pipeline, groupIndex); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBindPipelineShaderGroupNV\n"; } + device_dispatch_table(commandBuffer)->CmdBindPipelineShaderGroupNV(commandBuffer, pipelineBindPoint, pipeline, groupIndex); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutNV(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNV* pIndirectCommandsLayout) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateIndirectCommandsLayoutNV", "device, pCreateInfo, pAllocator, pIndirectCommandsLayout", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateIndirectCommandsLayoutNV(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pIndirectCommandsLayout); - } - } - VkResult result = device_dispatch_table(device)->CreateIndirectCommandsLayoutNV(device, pCreateInfo, pAllocator, pIndirectCommandsLayout); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateIndirectCommandsLayoutNV(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pIndirectCommandsLayout); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateIndirectCommandsLayoutNV\n"; } + VkResult result = device_dispatch_table(device)->CreateIndirectCommandsLayoutNV(device, pCreateInfo, pAllocator, pIndirectCommandsLayout); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutNV(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyIndirectCommandsLayoutNV", "device, indirectCommandsLayout, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyIndirectCommandsLayoutNV(ApiDumpInstance::current(), device, indirectCommandsLayout, pAllocator); - } - } - device_dispatch_table(device)->DestroyIndirectCommandsLayoutNV(device, indirectCommandsLayout, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyIndirectCommandsLayoutNV(ApiDumpInstance::current(), device, indirectCommandsLayout, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyIndirectCommandsLayoutNV\n"; } + device_dispatch_table(device)->DestroyIndirectCommandsLayoutNV(device, indirectCommandsLayout, pAllocator); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias2EXT(VkCommandBuffer commandBuffer, const VkDepthBiasInfoEXT* pDepthBiasInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetDepthBias2EXT", "commandBuffer, pDepthBiasInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDepthBias2EXT(ApiDumpInstance::current(), commandBuffer, pDepthBiasInfo); - } - } - device_dispatch_table(commandBuffer)->CmdSetDepthBias2EXT(commandBuffer, pDepthBiasInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDepthBias2EXT(ApiDumpInstance::current(), commandBuffer, pDepthBiasInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetDepthBias2EXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetDepthBias2EXT(commandBuffer, pDepthBiasInfo); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreatePrivateDataSlotEXT(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreatePrivateDataSlotEXT", "device, pCreateInfo, pAllocator, pPrivateDataSlot", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreatePrivateDataSlotEXT(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pPrivateDataSlot); - } - } - VkResult result = device_dispatch_table(device)->CreatePrivateDataSlotEXT(device, pCreateInfo, pAllocator, pPrivateDataSlot); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreatePrivateDataSlotEXT(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pPrivateDataSlot); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreatePrivateDataSlotEXT\n"; } + VkResult result = device_dispatch_table(device)->CreatePrivateDataSlotEXT(device, pCreateInfo, pAllocator, pPrivateDataSlot); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyPrivateDataSlotEXT", "device, privateDataSlot, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyPrivateDataSlotEXT(ApiDumpInstance::current(), device, privateDataSlot, pAllocator); - } - } - device_dispatch_table(device)->DestroyPrivateDataSlotEXT(device, privateDataSlot, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyPrivateDataSlotEXT(ApiDumpInstance::current(), device, privateDataSlot, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyPrivateDataSlotEXT\n"; } + device_dispatch_table(device)->DestroyPrivateDataSlotEXT(device, privateDataSlot, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkSetPrivateDataEXT", "device, objectType, objectHandle, privateDataSlot, data", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkSetPrivateDataEXT(ApiDumpInstance::current(), device, objectType, objectHandle, privateDataSlot, data); - } - } - VkResult result = device_dispatch_table(device)->SetPrivateDataEXT(device, objectType, objectHandle, privateDataSlot, data); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkSetPrivateDataEXT(ApiDumpInstance::current(), device, objectType, objectHandle, privateDataSlot, data); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkSetPrivateDataEXT\n"; } + VkResult result = device_dispatch_table(device)->SetPrivateDataEXT(device, objectType, objectHandle, privateDataSlot, data); return result; } template VKAPI_ATTR void VKAPI_CALL vkGetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPrivateDataEXT", "device, objectType, objectHandle, privateDataSlot, pData", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPrivateDataEXT(ApiDumpInstance::current(), device, objectType, objectHandle, privateDataSlot, pData); - } - } - device_dispatch_table(device)->GetPrivateDataEXT(device, objectType, objectHandle, privateDataSlot, pData); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPrivateDataEXT(ApiDumpInstance::current(), device, objectType, objectHandle, privateDataSlot, pData); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPrivateDataEXT\n"; } + device_dispatch_table(device)->GetPrivateDataEXT(device, objectType, objectHandle, privateDataSlot, pData); } #if defined(VK_ENABLE_BETA_EXTENSIONS) template VKAPI_ATTR VkResult VKAPI_CALL vkCreateCudaModuleNV(VkDevice device, const VkCudaModuleCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCudaModuleNV* pModule) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateCudaModuleNV", "device, pCreateInfo, pAllocator, pModule", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateCudaModuleNV(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pModule); - } - } - VkResult result = device_dispatch_table(device)->CreateCudaModuleNV(device, pCreateInfo, pAllocator, pModule); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateCudaModuleNV(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pModule); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateCudaModuleNV\n"; } + VkResult result = device_dispatch_table(device)->CreateCudaModuleNV(device, pCreateInfo, pAllocator, pModule); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetCudaModuleCacheNV(VkDevice device, VkCudaModuleNV module, size_t* pCacheSize, void* pCacheData) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetCudaModuleCacheNV", "device, module, pCacheSize, pCacheData", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetCudaModuleCacheNV(ApiDumpInstance::current(), device, module, pCacheSize, pCacheData); - } - } - VkResult result = device_dispatch_table(device)->GetCudaModuleCacheNV(device, module, pCacheSize, pCacheData); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetCudaModuleCacheNV(ApiDumpInstance::current(), device, module, pCacheSize, pCacheData); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetCudaModuleCacheNV\n"; } + VkResult result = device_dispatch_table(device)->GetCudaModuleCacheNV(device, module, pCacheSize, pCacheData); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateCudaFunctionNV(VkDevice device, const VkCudaFunctionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCudaFunctionNV* pFunction) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateCudaFunctionNV", "device, pCreateInfo, pAllocator, pFunction", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateCudaFunctionNV(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pFunction); - } - } - VkResult result = device_dispatch_table(device)->CreateCudaFunctionNV(device, pCreateInfo, pAllocator, pFunction); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateCudaFunctionNV(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pFunction); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateCudaFunctionNV\n"; } + VkResult result = device_dispatch_table(device)->CreateCudaFunctionNV(device, pCreateInfo, pAllocator, pFunction); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyCudaModuleNV(VkDevice device, VkCudaModuleNV module, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyCudaModuleNV", "device, module, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyCudaModuleNV(ApiDumpInstance::current(), device, module, pAllocator); - } - } - device_dispatch_table(device)->DestroyCudaModuleNV(device, module, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyCudaModuleNV(ApiDumpInstance::current(), device, module, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyCudaModuleNV\n"; } + device_dispatch_table(device)->DestroyCudaModuleNV(device, module, pAllocator); } template VKAPI_ATTR void VKAPI_CALL vkDestroyCudaFunctionNV(VkDevice device, VkCudaFunctionNV function, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyCudaFunctionNV", "device, function, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyCudaFunctionNV(ApiDumpInstance::current(), device, function, pAllocator); - } - } - device_dispatch_table(device)->DestroyCudaFunctionNV(device, function, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyCudaFunctionNV(ApiDumpInstance::current(), device, function, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyCudaFunctionNV\n"; } + device_dispatch_table(device)->DestroyCudaFunctionNV(device, function, pAllocator); } template VKAPI_ATTR void VKAPI_CALL vkCmdCudaLaunchKernelNV(VkCommandBuffer commandBuffer, const VkCudaLaunchInfoNV* pLaunchInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdCudaLaunchKernelNV", "commandBuffer, pLaunchInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCudaLaunchKernelNV(ApiDumpInstance::current(), commandBuffer, pLaunchInfo); - } - } - device_dispatch_table(commandBuffer)->CmdCudaLaunchKernelNV(commandBuffer, pLaunchInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCudaLaunchKernelNV(ApiDumpInstance::current(), commandBuffer, pLaunchInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdCudaLaunchKernelNV\n"; } + device_dispatch_table(commandBuffer)->CmdCudaLaunchKernelNV(commandBuffer, pLaunchInfo); } #endif // VK_ENABLE_BETA_EXTENSIONS template VKAPI_ATTR void VKAPI_CALL vkCmdDispatchTileQCOM(VkCommandBuffer commandBuffer, const VkDispatchTileInfoQCOM* pDispatchTileInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdDispatchTileQCOM", "commandBuffer, pDispatchTileInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDispatchTileQCOM(ApiDumpInstance::current(), commandBuffer, pDispatchTileInfo); - } - } - device_dispatch_table(commandBuffer)->CmdDispatchTileQCOM(commandBuffer, pDispatchTileInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDispatchTileQCOM(ApiDumpInstance::current(), commandBuffer, pDispatchTileInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdDispatchTileQCOM\n"; } + device_dispatch_table(commandBuffer)->CmdDispatchTileQCOM(commandBuffer, pDispatchTileInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdBeginPerTileExecutionQCOM(VkCommandBuffer commandBuffer, const VkPerTileBeginInfoQCOM* pPerTileBeginInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBeginPerTileExecutionQCOM", "commandBuffer, pPerTileBeginInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBeginPerTileExecutionQCOM(ApiDumpInstance::current(), commandBuffer, pPerTileBeginInfo); - } - } - device_dispatch_table(commandBuffer)->CmdBeginPerTileExecutionQCOM(commandBuffer, pPerTileBeginInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBeginPerTileExecutionQCOM(ApiDumpInstance::current(), commandBuffer, pPerTileBeginInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBeginPerTileExecutionQCOM\n"; } + device_dispatch_table(commandBuffer)->CmdBeginPerTileExecutionQCOM(commandBuffer, pPerTileBeginInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdEndPerTileExecutionQCOM(VkCommandBuffer commandBuffer, const VkPerTileEndInfoQCOM* pPerTileEndInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdEndPerTileExecutionQCOM", "commandBuffer, pPerTileEndInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdEndPerTileExecutionQCOM(ApiDumpInstance::current(), commandBuffer, pPerTileEndInfo); - } - } - device_dispatch_table(commandBuffer)->CmdEndPerTileExecutionQCOM(commandBuffer, pPerTileEndInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdEndPerTileExecutionQCOM(ApiDumpInstance::current(), commandBuffer, pPerTileEndInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdEndPerTileExecutionQCOM\n"; } + device_dispatch_table(commandBuffer)->CmdEndPerTileExecutionQCOM(commandBuffer, pPerTileEndInfo); } #if defined(VK_USE_PLATFORM_METAL_EXT) template VKAPI_ATTR void VKAPI_CALL vkExportMetalObjectsEXT(VkDevice device, VkExportMetalObjectsInfoEXT* pMetalObjectsInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkExportMetalObjectsEXT", "device, pMetalObjectsInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkExportMetalObjectsEXT(ApiDumpInstance::current(), device, pMetalObjectsInfo); - } - } - device_dispatch_table(device)->ExportMetalObjectsEXT(device, pMetalObjectsInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkExportMetalObjectsEXT(ApiDumpInstance::current(), device, pMetalObjectsInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkExportMetalObjectsEXT\n"; } + device_dispatch_table(device)->ExportMetalObjectsEXT(device, pMetalObjectsInfo); } #endif // VK_USE_PLATFORM_METAL_EXT template VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSizeEXT(VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize* pLayoutSizeInBytes) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDescriptorSetLayoutSizeEXT", "device, layout, pLayoutSizeInBytes", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDescriptorSetLayoutSizeEXT(ApiDumpInstance::current(), device, layout, pLayoutSizeInBytes); - } - } - device_dispatch_table(device)->GetDescriptorSetLayoutSizeEXT(device, layout, pLayoutSizeInBytes); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDescriptorSetLayoutSizeEXT(ApiDumpInstance::current(), device, layout, pLayoutSizeInBytes); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDescriptorSetLayoutSizeEXT\n"; } + device_dispatch_table(device)->GetDescriptorSetLayoutSizeEXT(device, layout, pLayoutSizeInBytes); } template VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutBindingOffsetEXT(VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize* pOffset) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDescriptorSetLayoutBindingOffsetEXT", "device, layout, binding, pOffset", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDescriptorSetLayoutBindingOffsetEXT(ApiDumpInstance::current(), device, layout, binding, pOffset); - } - } - device_dispatch_table(device)->GetDescriptorSetLayoutBindingOffsetEXT(device, layout, binding, pOffset); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDescriptorSetLayoutBindingOffsetEXT(ApiDumpInstance::current(), device, layout, binding, pOffset); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDescriptorSetLayoutBindingOffsetEXT\n"; } + device_dispatch_table(device)->GetDescriptorSetLayoutBindingOffsetEXT(device, layout, binding, pOffset); } template VKAPI_ATTR void VKAPI_CALL vkGetDescriptorEXT(VkDevice device, const VkDescriptorGetInfoEXT* pDescriptorInfo, size_t dataSize, void* pDescriptor) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDescriptorEXT", "device, pDescriptorInfo, dataSize, pDescriptor", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDescriptorEXT(ApiDumpInstance::current(), device, pDescriptorInfo, dataSize, pDescriptor); - } - } - device_dispatch_table(device)->GetDescriptorEXT(device, pDescriptorInfo, dataSize, pDescriptor); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDescriptorEXT(ApiDumpInstance::current(), device, pDescriptorInfo, dataSize, pDescriptor); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDescriptorEXT\n"; } + device_dispatch_table(device)->GetDescriptorEXT(device, pDescriptorInfo, dataSize, pDescriptor); } template VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorBuffersEXT(VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT* pBindingInfos) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBindDescriptorBuffersEXT", "commandBuffer, bufferCount, pBindingInfos", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBindDescriptorBuffersEXT(ApiDumpInstance::current(), commandBuffer, bufferCount, pBindingInfos); - } - } - device_dispatch_table(commandBuffer)->CmdBindDescriptorBuffersEXT(commandBuffer, bufferCount, pBindingInfos); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBindDescriptorBuffersEXT(ApiDumpInstance::current(), commandBuffer, bufferCount, pBindingInfos); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBindDescriptorBuffersEXT\n"; } + device_dispatch_table(commandBuffer)->CmdBindDescriptorBuffersEXT(commandBuffer, bufferCount, pBindingInfos); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDescriptorBufferOffsetsEXT(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t* pBufferIndices, const VkDeviceSize* pOffsets) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetDescriptorBufferOffsetsEXT", "commandBuffer, pipelineBindPoint, layout, firstSet, setCount, pBufferIndices, pOffsets", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDescriptorBufferOffsetsEXT(ApiDumpInstance::current(), commandBuffer, pipelineBindPoint, layout, firstSet, setCount, pBufferIndices, pOffsets); - } - } - device_dispatch_table(commandBuffer)->CmdSetDescriptorBufferOffsetsEXT(commandBuffer, pipelineBindPoint, layout, firstSet, setCount, pBufferIndices, pOffsets); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDescriptorBufferOffsetsEXT(ApiDumpInstance::current(), commandBuffer, pipelineBindPoint, layout, firstSet, setCount, pBufferIndices, pOffsets); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetDescriptorBufferOffsetsEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetDescriptorBufferOffsetsEXT(commandBuffer, pipelineBindPoint, layout, firstSet, setCount, pBufferIndices, pOffsets); } template VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorBufferEmbeddedSamplersEXT(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBindDescriptorBufferEmbeddedSamplersEXT", "commandBuffer, pipelineBindPoint, layout, set", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBindDescriptorBufferEmbeddedSamplersEXT(ApiDumpInstance::current(), commandBuffer, pipelineBindPoint, layout, set); - } - } - device_dispatch_table(commandBuffer)->CmdBindDescriptorBufferEmbeddedSamplersEXT(commandBuffer, pipelineBindPoint, layout, set); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBindDescriptorBufferEmbeddedSamplersEXT(ApiDumpInstance::current(), commandBuffer, pipelineBindPoint, layout, set); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBindDescriptorBufferEmbeddedSamplersEXT\n"; } + device_dispatch_table(commandBuffer)->CmdBindDescriptorBufferEmbeddedSamplersEXT(commandBuffer, pipelineBindPoint, layout, set); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetBufferOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT* pInfo, void* pData) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetBufferOpaqueCaptureDescriptorDataEXT", "device, pInfo, pData", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetBufferOpaqueCaptureDescriptorDataEXT(ApiDumpInstance::current(), device, pInfo, pData); - } - } - VkResult result = device_dispatch_table(device)->GetBufferOpaqueCaptureDescriptorDataEXT(device, pInfo, pData); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetBufferOpaqueCaptureDescriptorDataEXT(ApiDumpInstance::current(), device, pInfo, pData); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetBufferOpaqueCaptureDescriptorDataEXT\n"; } + VkResult result = device_dispatch_table(device)->GetBufferOpaqueCaptureDescriptorDataEXT(device, pInfo, pData); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetImageOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkImageCaptureDescriptorDataInfoEXT* pInfo, void* pData) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetImageOpaqueCaptureDescriptorDataEXT", "device, pInfo, pData", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetImageOpaqueCaptureDescriptorDataEXT(ApiDumpInstance::current(), device, pInfo, pData); - } - } - VkResult result = device_dispatch_table(device)->GetImageOpaqueCaptureDescriptorDataEXT(device, pInfo, pData); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetImageOpaqueCaptureDescriptorDataEXT(ApiDumpInstance::current(), device, pInfo, pData); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetImageOpaqueCaptureDescriptorDataEXT\n"; } + VkResult result = device_dispatch_table(device)->GetImageOpaqueCaptureDescriptorDataEXT(device, pInfo, pData); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetImageViewOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, void* pData) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetImageViewOpaqueCaptureDescriptorDataEXT", "device, pInfo, pData", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetImageViewOpaqueCaptureDescriptorDataEXT(ApiDumpInstance::current(), device, pInfo, pData); - } - } - VkResult result = device_dispatch_table(device)->GetImageViewOpaqueCaptureDescriptorDataEXT(device, pInfo, pData); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetImageViewOpaqueCaptureDescriptorDataEXT(ApiDumpInstance::current(), device, pInfo, pData); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetImageViewOpaqueCaptureDescriptorDataEXT\n"; } + VkResult result = device_dispatch_table(device)->GetImageViewOpaqueCaptureDescriptorDataEXT(device, pInfo, pData); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetSamplerOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT* pInfo, void* pData) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetSamplerOpaqueCaptureDescriptorDataEXT", "device, pInfo, pData", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetSamplerOpaqueCaptureDescriptorDataEXT(ApiDumpInstance::current(), device, pInfo, pData); - } - } - VkResult result = device_dispatch_table(device)->GetSamplerOpaqueCaptureDescriptorDataEXT(device, pInfo, pData); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetSamplerOpaqueCaptureDescriptorDataEXT(ApiDumpInstance::current(), device, pInfo, pData); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetSamplerOpaqueCaptureDescriptorDataEXT\n"; } + VkResult result = device_dispatch_table(device)->GetSamplerOpaqueCaptureDescriptorDataEXT(device, pInfo, pData); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, void* pData) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT", "device, pInfo, pData", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(ApiDumpInstance::current(), device, pInfo, pData); - } - } - VkResult result = device_dispatch_table(device)->GetAccelerationStructureOpaqueCaptureDescriptorDataEXT(device, pInfo, pData); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(ApiDumpInstance::current(), device, pInfo, pData); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT\n"; } + VkResult result = device_dispatch_table(device)->GetAccelerationStructureOpaqueCaptureDescriptorDataEXT(device, pInfo, pData); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateEnumNV(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetFragmentShadingRateEnumNV", "commandBuffer, shadingRate, combinerOps", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetFragmentShadingRateEnumNV(ApiDumpInstance::current(), commandBuffer, shadingRate, combinerOps); - } - } - device_dispatch_table(commandBuffer)->CmdSetFragmentShadingRateEnumNV(commandBuffer, shadingRate, combinerOps); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetFragmentShadingRateEnumNV(ApiDumpInstance::current(), commandBuffer, shadingRate, combinerOps); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetFragmentShadingRateEnumNV\n"; } + device_dispatch_table(commandBuffer)->CmdSetFragmentShadingRateEnumNV(commandBuffer, shadingRate, combinerOps); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceFaultInfoEXT(VkDevice device, VkDeviceFaultCountsEXT* pFaultCounts, VkDeviceFaultInfoEXT* pFaultInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDeviceFaultInfoEXT", "device, pFaultCounts, pFaultInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceFaultInfoEXT(ApiDumpInstance::current(), device, pFaultCounts, pFaultInfo); - } - } - VkResult result = device_dispatch_table(device)->GetDeviceFaultInfoEXT(device, pFaultCounts, pFaultInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceFaultInfoEXT(ApiDumpInstance::current(), device, pFaultCounts, pFaultInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDeviceFaultInfoEXT\n"; } + VkResult result = device_dispatch_table(device)->GetDeviceFaultInfoEXT(device, pFaultCounts, pFaultInfo); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdSetVertexInputEXT(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetVertexInputEXT", "commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetVertexInputEXT(ApiDumpInstance::current(), commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions); - } - } - device_dispatch_table(commandBuffer)->CmdSetVertexInputEXT(commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetVertexInputEXT(ApiDumpInstance::current(), commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetVertexInputEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetVertexInputEXT(commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions); } #if defined(VK_USE_PLATFORM_FUCHSIA) template VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryZirconHandleFUCHSIA(VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetMemoryZirconHandleFUCHSIA", "device, pGetZirconHandleInfo, pZirconHandle", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetMemoryZirconHandleFUCHSIA(ApiDumpInstance::current(), device, pGetZirconHandleInfo, pZirconHandle); - } - } - VkResult result = device_dispatch_table(device)->GetMemoryZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetMemoryZirconHandleFUCHSIA(ApiDumpInstance::current(), device, pGetZirconHandleInfo, pZirconHandle); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetMemoryZirconHandleFUCHSIA\n"; } + VkResult result = device_dispatch_table(device)->GetMemoryZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryZirconHandlePropertiesFUCHSIA(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetMemoryZirconHandlePropertiesFUCHSIA", "device, handleType, zirconHandle, pMemoryZirconHandleProperties", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetMemoryZirconHandlePropertiesFUCHSIA(ApiDumpInstance::current(), device, handleType, zirconHandle, pMemoryZirconHandleProperties); - } - } - VkResult result = device_dispatch_table(device)->GetMemoryZirconHandlePropertiesFUCHSIA(device, handleType, zirconHandle, pMemoryZirconHandleProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetMemoryZirconHandlePropertiesFUCHSIA(ApiDumpInstance::current(), device, handleType, zirconHandle, pMemoryZirconHandleProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetMemoryZirconHandlePropertiesFUCHSIA\n"; } + VkResult result = device_dispatch_table(device)->GetMemoryZirconHandlePropertiesFUCHSIA(device, handleType, zirconHandle, pMemoryZirconHandleProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreZirconHandleFUCHSIA(VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkImportSemaphoreZirconHandleFUCHSIA", "device, pImportSemaphoreZirconHandleInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkImportSemaphoreZirconHandleFUCHSIA(ApiDumpInstance::current(), device, pImportSemaphoreZirconHandleInfo); - } - } - VkResult result = device_dispatch_table(device)->ImportSemaphoreZirconHandleFUCHSIA(device, pImportSemaphoreZirconHandleInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkImportSemaphoreZirconHandleFUCHSIA(ApiDumpInstance::current(), device, pImportSemaphoreZirconHandleInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkImportSemaphoreZirconHandleFUCHSIA\n"; } + VkResult result = device_dispatch_table(device)->ImportSemaphoreZirconHandleFUCHSIA(device, pImportSemaphoreZirconHandleInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreZirconHandleFUCHSIA(VkDevice device, const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetSemaphoreZirconHandleFUCHSIA", "device, pGetZirconHandleInfo, pZirconHandle", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetSemaphoreZirconHandleFUCHSIA(ApiDumpInstance::current(), device, pGetZirconHandleInfo, pZirconHandle); - } - } - VkResult result = device_dispatch_table(device)->GetSemaphoreZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetSemaphoreZirconHandleFUCHSIA(ApiDumpInstance::current(), device, pGetZirconHandleInfo, pZirconHandle); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetSemaphoreZirconHandleFUCHSIA\n"; } + VkResult result = device_dispatch_table(device)->GetSemaphoreZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferCollectionFUCHSIA(VkDevice device, const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferCollectionFUCHSIA* pCollection) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateBufferCollectionFUCHSIA", "device, pCreateInfo, pAllocator, pCollection", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateBufferCollectionFUCHSIA(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pCollection); - } - } - VkResult result = device_dispatch_table(device)->CreateBufferCollectionFUCHSIA(device, pCreateInfo, pAllocator, pCollection); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateBufferCollectionFUCHSIA(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pCollection); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateBufferCollectionFUCHSIA\n"; } + VkResult result = device_dispatch_table(device)->CreateBufferCollectionFUCHSIA(device, pCreateInfo, pAllocator, pCollection); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkSetBufferCollectionImageConstraintsFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkSetBufferCollectionImageConstraintsFUCHSIA", "device, collection, pImageConstraintsInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkSetBufferCollectionImageConstraintsFUCHSIA(ApiDumpInstance::current(), device, collection, pImageConstraintsInfo); - } - } - VkResult result = device_dispatch_table(device)->SetBufferCollectionImageConstraintsFUCHSIA(device, collection, pImageConstraintsInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkSetBufferCollectionImageConstraintsFUCHSIA(ApiDumpInstance::current(), device, collection, pImageConstraintsInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkSetBufferCollectionImageConstraintsFUCHSIA\n"; } + VkResult result = device_dispatch_table(device)->SetBufferCollectionImageConstraintsFUCHSIA(device, collection, pImageConstraintsInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkSetBufferCollectionBufferConstraintsFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkSetBufferCollectionBufferConstraintsFUCHSIA", "device, collection, pBufferConstraintsInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkSetBufferCollectionBufferConstraintsFUCHSIA(ApiDumpInstance::current(), device, collection, pBufferConstraintsInfo); - } - } - VkResult result = device_dispatch_table(device)->SetBufferCollectionBufferConstraintsFUCHSIA(device, collection, pBufferConstraintsInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkSetBufferCollectionBufferConstraintsFUCHSIA(ApiDumpInstance::current(), device, collection, pBufferConstraintsInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkSetBufferCollectionBufferConstraintsFUCHSIA\n"; } + VkResult result = device_dispatch_table(device)->SetBufferCollectionBufferConstraintsFUCHSIA(device, collection, pBufferConstraintsInfo); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyBufferCollectionFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyBufferCollectionFUCHSIA", "device, collection, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyBufferCollectionFUCHSIA(ApiDumpInstance::current(), device, collection, pAllocator); - } - } - device_dispatch_table(device)->DestroyBufferCollectionFUCHSIA(device, collection, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyBufferCollectionFUCHSIA(ApiDumpInstance::current(), device, collection, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyBufferCollectionFUCHSIA\n"; } + device_dispatch_table(device)->DestroyBufferCollectionFUCHSIA(device, collection, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetBufferCollectionPropertiesFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, VkBufferCollectionPropertiesFUCHSIA* pProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetBufferCollectionPropertiesFUCHSIA", "device, collection, pProperties", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetBufferCollectionPropertiesFUCHSIA(ApiDumpInstance::current(), device, collection, pProperties); - } - } - VkResult result = device_dispatch_table(device)->GetBufferCollectionPropertiesFUCHSIA(device, collection, pProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetBufferCollectionPropertiesFUCHSIA(ApiDumpInstance::current(), device, collection, pProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetBufferCollectionPropertiesFUCHSIA\n"; } + VkResult result = device_dispatch_table(device)->GetBufferCollectionPropertiesFUCHSIA(device, collection, pProperties); return result; } #endif // VK_USE_PLATFORM_FUCHSIA @@ -12150,761 +5798,361 @@ template VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(VkDevice device, VkRenderPass renderpass, VkExtent2D* pMaxWorkgroupSize) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI", "device, renderpass, pMaxWorkgroupSize", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(ApiDumpInstance::current(), device, renderpass, pMaxWorkgroupSize); - } - } - VkResult result = device_dispatch_table(device)->GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(device, renderpass, pMaxWorkgroupSize); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(ApiDumpInstance::current(), device, renderpass, pMaxWorkgroupSize); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI\n"; } + VkResult result = device_dispatch_table(device)->GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(device, renderpass, pMaxWorkgroupSize); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdSubpassShadingHUAWEI(VkCommandBuffer commandBuffer) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSubpassShadingHUAWEI", "commandBuffer", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSubpassShadingHUAWEI(ApiDumpInstance::current(), commandBuffer); - } - } - device_dispatch_table(commandBuffer)->CmdSubpassShadingHUAWEI(commandBuffer); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSubpassShadingHUAWEI(ApiDumpInstance::current(), commandBuffer); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSubpassShadingHUAWEI\n"; } + device_dispatch_table(commandBuffer)->CmdSubpassShadingHUAWEI(commandBuffer); } template VKAPI_ATTR void VKAPI_CALL vkCmdBindInvocationMaskHUAWEI(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBindInvocationMaskHUAWEI", "commandBuffer, imageView, imageLayout", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBindInvocationMaskHUAWEI(ApiDumpInstance::current(), commandBuffer, imageView, imageLayout); - } - } - device_dispatch_table(commandBuffer)->CmdBindInvocationMaskHUAWEI(commandBuffer, imageView, imageLayout); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBindInvocationMaskHUAWEI(ApiDumpInstance::current(), commandBuffer, imageView, imageLayout); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBindInvocationMaskHUAWEI\n"; } + device_dispatch_table(commandBuffer)->CmdBindInvocationMaskHUAWEI(commandBuffer, imageView, imageLayout); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryRemoteAddressNV(VkDevice device, const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, VkRemoteAddressNV* pAddress) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetMemoryRemoteAddressNV", "device, pMemoryGetRemoteAddressInfo, pAddress", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetMemoryRemoteAddressNV(ApiDumpInstance::current(), device, pMemoryGetRemoteAddressInfo, pAddress); - } - } - VkResult result = device_dispatch_table(device)->GetMemoryRemoteAddressNV(device, pMemoryGetRemoteAddressInfo, pAddress); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetMemoryRemoteAddressNV(ApiDumpInstance::current(), device, pMemoryGetRemoteAddressInfo, pAddress); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetMemoryRemoteAddressNV\n"; } + VkResult result = device_dispatch_table(device)->GetMemoryRemoteAddressNV(device, pMemoryGetRemoteAddressInfo, pAddress); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelinePropertiesEXT(VkDevice device, const VkPipelineInfoEXT* pPipelineInfo, VkBaseOutStructure* pPipelineProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPipelinePropertiesEXT", "device, pPipelineInfo, pPipelineProperties", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPipelinePropertiesEXT(ApiDumpInstance::current(), device, pPipelineInfo, pPipelineProperties); - } - } - VkResult result = device_dispatch_table(device)->GetPipelinePropertiesEXT(device, pPipelineInfo, pPipelineProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPipelinePropertiesEXT(ApiDumpInstance::current(), device, pPipelineInfo, pPipelineProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPipelinePropertiesEXT\n"; } + VkResult result = device_dispatch_table(device)->GetPipelinePropertiesEXT(device, pPipelineInfo, pPipelineProperties); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetPatchControlPointsEXT", "commandBuffer, patchControlPoints", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetPatchControlPointsEXT(ApiDumpInstance::current(), commandBuffer, patchControlPoints); - } - } - device_dispatch_table(commandBuffer)->CmdSetPatchControlPointsEXT(commandBuffer, patchControlPoints); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetPatchControlPointsEXT(ApiDumpInstance::current(), commandBuffer, patchControlPoints); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetPatchControlPointsEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetPatchControlPointsEXT(commandBuffer, patchControlPoints); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetRasterizerDiscardEnableEXT", "commandBuffer, rasterizerDiscardEnable", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetRasterizerDiscardEnableEXT(ApiDumpInstance::current(), commandBuffer, rasterizerDiscardEnable); - } - } - device_dispatch_table(commandBuffer)->CmdSetRasterizerDiscardEnableEXT(commandBuffer, rasterizerDiscardEnable); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetRasterizerDiscardEnableEXT(ApiDumpInstance::current(), commandBuffer, rasterizerDiscardEnable); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetRasterizerDiscardEnableEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetRasterizerDiscardEnableEXT(commandBuffer, rasterizerDiscardEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetDepthBiasEnableEXT", "commandBuffer, depthBiasEnable", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDepthBiasEnableEXT(ApiDumpInstance::current(), commandBuffer, depthBiasEnable); - } - } - device_dispatch_table(commandBuffer)->CmdSetDepthBiasEnableEXT(commandBuffer, depthBiasEnable); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDepthBiasEnableEXT(ApiDumpInstance::current(), commandBuffer, depthBiasEnable); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetDepthBiasEnableEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetDepthBiasEnableEXT(commandBuffer, depthBiasEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetLogicOpEXT", "commandBuffer, logicOp", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetLogicOpEXT(ApiDumpInstance::current(), commandBuffer, logicOp); - } - } - device_dispatch_table(commandBuffer)->CmdSetLogicOpEXT(commandBuffer, logicOp); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetLogicOpEXT(ApiDumpInstance::current(), commandBuffer, logicOp); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetLogicOpEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetLogicOpEXT(commandBuffer, logicOp); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetPrimitiveRestartEnableEXT", "commandBuffer, primitiveRestartEnable", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetPrimitiveRestartEnableEXT(ApiDumpInstance::current(), commandBuffer, primitiveRestartEnable); - } - } - device_dispatch_table(commandBuffer)->CmdSetPrimitiveRestartEnableEXT(commandBuffer, primitiveRestartEnable); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetPrimitiveRestartEnableEXT(ApiDumpInstance::current(), commandBuffer, primitiveRestartEnable); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetPrimitiveRestartEnableEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetPrimitiveRestartEnableEXT(commandBuffer, primitiveRestartEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetColorWriteEnableEXT", "commandBuffer, attachmentCount, pColorWriteEnables", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetColorWriteEnableEXT(ApiDumpInstance::current(), commandBuffer, attachmentCount, pColorWriteEnables); - } - } - device_dispatch_table(commandBuffer)->CmdSetColorWriteEnableEXT(commandBuffer, attachmentCount, pColorWriteEnables); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetColorWriteEnableEXT(ApiDumpInstance::current(), commandBuffer, attachmentCount, pColorWriteEnables); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetColorWriteEnableEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetColorWriteEnableEXT(commandBuffer, attachmentCount, pColorWriteEnables); } template VKAPI_ATTR void VKAPI_CALL vkCmdDrawMultiEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdDrawMultiEXT", "commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDrawMultiEXT(ApiDumpInstance::current(), commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride); - } - } - device_dispatch_table(commandBuffer)->CmdDrawMultiEXT(commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDrawMultiEXT(ApiDumpInstance::current(), commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdDrawMultiEXT\n"; } + device_dispatch_table(commandBuffer)->CmdDrawMultiEXT(commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride); } template VKAPI_ATTR void VKAPI_CALL vkCmdDrawMultiIndexedEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdDrawMultiIndexedEXT", "commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDrawMultiIndexedEXT(ApiDumpInstance::current(), commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset); - } - } - device_dispatch_table(commandBuffer)->CmdDrawMultiIndexedEXT(commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDrawMultiIndexedEXT(ApiDumpInstance::current(), commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdDrawMultiIndexedEXT\n"; } + device_dispatch_table(commandBuffer)->CmdDrawMultiIndexedEXT(commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateMicromapEXT(VkDevice device, const VkMicromapCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkMicromapEXT* pMicromap) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateMicromapEXT", "device, pCreateInfo, pAllocator, pMicromap", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateMicromapEXT(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pMicromap); - } - } - VkResult result = device_dispatch_table(device)->CreateMicromapEXT(device, pCreateInfo, pAllocator, pMicromap); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateMicromapEXT(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pMicromap); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateMicromapEXT\n"; } + VkResult result = device_dispatch_table(device)->CreateMicromapEXT(device, pCreateInfo, pAllocator, pMicromap); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyMicromapEXT(VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyMicromapEXT", "device, micromap, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyMicromapEXT(ApiDumpInstance::current(), device, micromap, pAllocator); - } - } - device_dispatch_table(device)->DestroyMicromapEXT(device, micromap, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyMicromapEXT(ApiDumpInstance::current(), device, micromap, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyMicromapEXT\n"; } + device_dispatch_table(device)->DestroyMicromapEXT(device, micromap, pAllocator); } template VKAPI_ATTR void VKAPI_CALL vkCmdBuildMicromapsEXT(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBuildMicromapsEXT", "commandBuffer, infoCount, pInfos", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBuildMicromapsEXT(ApiDumpInstance::current(), commandBuffer, infoCount, pInfos); - } - } - device_dispatch_table(commandBuffer)->CmdBuildMicromapsEXT(commandBuffer, infoCount, pInfos); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBuildMicromapsEXT(ApiDumpInstance::current(), commandBuffer, infoCount, pInfos); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBuildMicromapsEXT\n"; } + device_dispatch_table(commandBuffer)->CmdBuildMicromapsEXT(commandBuffer, infoCount, pInfos); } template VKAPI_ATTR VkResult VKAPI_CALL vkBuildMicromapsEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkBuildMicromapsEXT", "device, deferredOperation, infoCount, pInfos", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkBuildMicromapsEXT(ApiDumpInstance::current(), device, deferredOperation, infoCount, pInfos); - } - } - VkResult result = device_dispatch_table(device)->BuildMicromapsEXT(device, deferredOperation, infoCount, pInfos); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkBuildMicromapsEXT(ApiDumpInstance::current(), device, deferredOperation, infoCount, pInfos); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkBuildMicromapsEXT\n"; } + VkResult result = device_dispatch_table(device)->BuildMicromapsEXT(device, deferredOperation, infoCount, pInfos); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCopyMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT* pInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCopyMicromapEXT", "device, deferredOperation, pInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCopyMicromapEXT(ApiDumpInstance::current(), device, deferredOperation, pInfo); - } - } - VkResult result = device_dispatch_table(device)->CopyMicromapEXT(device, deferredOperation, pInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCopyMicromapEXT(ApiDumpInstance::current(), device, deferredOperation, pInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCopyMicromapEXT\n"; } + VkResult result = device_dispatch_table(device)->CopyMicromapEXT(device, deferredOperation, pInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCopyMicromapToMemoryEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT* pInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCopyMicromapToMemoryEXT", "device, deferredOperation, pInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCopyMicromapToMemoryEXT(ApiDumpInstance::current(), device, deferredOperation, pInfo); - } - } - VkResult result = device_dispatch_table(device)->CopyMicromapToMemoryEXT(device, deferredOperation, pInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCopyMicromapToMemoryEXT(ApiDumpInstance::current(), device, deferredOperation, pInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCopyMicromapToMemoryEXT\n"; } + VkResult result = device_dispatch_table(device)->CopyMicromapToMemoryEXT(device, deferredOperation, pInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT* pInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCopyMemoryToMicromapEXT", "device, deferredOperation, pInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCopyMemoryToMicromapEXT(ApiDumpInstance::current(), device, deferredOperation, pInfo); - } - } - VkResult result = device_dispatch_table(device)->CopyMemoryToMicromapEXT(device, deferredOperation, pInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCopyMemoryToMicromapEXT(ApiDumpInstance::current(), device, deferredOperation, pInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCopyMemoryToMicromapEXT\n"; } + VkResult result = device_dispatch_table(device)->CopyMemoryToMicromapEXT(device, deferredOperation, pInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, size_t dataSize, void* pData, size_t stride) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkWriteMicromapsPropertiesEXT", "device, micromapCount, pMicromaps, queryType, dataSize, pData, stride", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkWriteMicromapsPropertiesEXT(ApiDumpInstance::current(), device, micromapCount, pMicromaps, queryType, dataSize, pData, stride); - } - } - VkResult result = device_dispatch_table(device)->WriteMicromapsPropertiesEXT(device, micromapCount, pMicromaps, queryType, dataSize, pData, stride); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkWriteMicromapsPropertiesEXT(ApiDumpInstance::current(), device, micromapCount, pMicromaps, queryType, dataSize, pData, stride); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkWriteMicromapsPropertiesEXT\n"; } + VkResult result = device_dispatch_table(device)->WriteMicromapsPropertiesEXT(device, micromapCount, pMicromaps, queryType, dataSize, pData, stride); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT* pInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdCopyMicromapEXT", "commandBuffer, pInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyMicromapEXT(ApiDumpInstance::current(), commandBuffer, pInfo); - } - } - device_dispatch_table(commandBuffer)->CmdCopyMicromapEXT(commandBuffer, pInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyMicromapEXT(ApiDumpInstance::current(), commandBuffer, pInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdCopyMicromapEXT\n"; } + device_dispatch_table(commandBuffer)->CmdCopyMicromapEXT(commandBuffer, pInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyMicromapToMemoryEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT* pInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdCopyMicromapToMemoryEXT", "commandBuffer, pInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyMicromapToMemoryEXT(ApiDumpInstance::current(), commandBuffer, pInfo); - } - } - device_dispatch_table(commandBuffer)->CmdCopyMicromapToMemoryEXT(commandBuffer, pInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyMicromapToMemoryEXT(ApiDumpInstance::current(), commandBuffer, pInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdCopyMicromapToMemoryEXT\n"; } + device_dispatch_table(commandBuffer)->CmdCopyMicromapToMemoryEXT(commandBuffer, pInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT* pInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdCopyMemoryToMicromapEXT", "commandBuffer, pInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyMemoryToMicromapEXT(ApiDumpInstance::current(), commandBuffer, pInfo); - } - } - device_dispatch_table(commandBuffer)->CmdCopyMemoryToMicromapEXT(commandBuffer, pInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyMemoryToMicromapEXT(ApiDumpInstance::current(), commandBuffer, pInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdCopyMemoryToMicromapEXT\n"; } + device_dispatch_table(commandBuffer)->CmdCopyMemoryToMicromapEXT(commandBuffer, pInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdWriteMicromapsPropertiesEXT(VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdWriteMicromapsPropertiesEXT", "commandBuffer, micromapCount, pMicromaps, queryType, queryPool, firstQuery", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdWriteMicromapsPropertiesEXT(ApiDumpInstance::current(), commandBuffer, micromapCount, pMicromaps, queryType, queryPool, firstQuery); - } - } - device_dispatch_table(commandBuffer)->CmdWriteMicromapsPropertiesEXT(commandBuffer, micromapCount, pMicromaps, queryType, queryPool, firstQuery); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdWriteMicromapsPropertiesEXT(ApiDumpInstance::current(), commandBuffer, micromapCount, pMicromaps, queryType, queryPool, firstQuery); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdWriteMicromapsPropertiesEXT\n"; } + device_dispatch_table(commandBuffer)->CmdWriteMicromapsPropertiesEXT(commandBuffer, micromapCount, pMicromaps, queryType, queryPool, firstQuery); } template VKAPI_ATTR void VKAPI_CALL vkGetDeviceMicromapCompatibilityEXT(VkDevice device, const VkMicromapVersionInfoEXT* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDeviceMicromapCompatibilityEXT", "device, pVersionInfo, pCompatibility", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceMicromapCompatibilityEXT(ApiDumpInstance::current(), device, pVersionInfo, pCompatibility); - } - } - device_dispatch_table(device)->GetDeviceMicromapCompatibilityEXT(device, pVersionInfo, pCompatibility); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceMicromapCompatibilityEXT(ApiDumpInstance::current(), device, pVersionInfo, pCompatibility); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDeviceMicromapCompatibilityEXT\n"; } + device_dispatch_table(device)->GetDeviceMicromapCompatibilityEXT(device, pVersionInfo, pCompatibility); } template VKAPI_ATTR void VKAPI_CALL vkGetMicromapBuildSizesEXT(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT* pBuildInfo, VkMicromapBuildSizesInfoEXT* pSizeInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetMicromapBuildSizesEXT", "device, buildType, pBuildInfo, pSizeInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetMicromapBuildSizesEXT(ApiDumpInstance::current(), device, buildType, pBuildInfo, pSizeInfo); - } - } - device_dispatch_table(device)->GetMicromapBuildSizesEXT(device, buildType, pBuildInfo, pSizeInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetMicromapBuildSizesEXT(ApiDumpInstance::current(), device, buildType, pBuildInfo, pSizeInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetMicromapBuildSizesEXT\n"; } + device_dispatch_table(device)->GetMicromapBuildSizesEXT(device, buildType, pBuildInfo, pSizeInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdDrawClusterHUAWEI(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdDrawClusterHUAWEI", "commandBuffer, groupCountX, groupCountY, groupCountZ", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDrawClusterHUAWEI(ApiDumpInstance::current(), commandBuffer, groupCountX, groupCountY, groupCountZ); - } - } - device_dispatch_table(commandBuffer)->CmdDrawClusterHUAWEI(commandBuffer, groupCountX, groupCountY, groupCountZ); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDrawClusterHUAWEI(ApiDumpInstance::current(), commandBuffer, groupCountX, groupCountY, groupCountZ); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdDrawClusterHUAWEI\n"; } + device_dispatch_table(commandBuffer)->CmdDrawClusterHUAWEI(commandBuffer, groupCountX, groupCountY, groupCountZ); } template VKAPI_ATTR void VKAPI_CALL vkCmdDrawClusterIndirectHUAWEI(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdDrawClusterIndirectHUAWEI", "commandBuffer, buffer, offset", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDrawClusterIndirectHUAWEI(ApiDumpInstance::current(), commandBuffer, buffer, offset); - } - } - device_dispatch_table(commandBuffer)->CmdDrawClusterIndirectHUAWEI(commandBuffer, buffer, offset); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDrawClusterIndirectHUAWEI(ApiDumpInstance::current(), commandBuffer, buffer, offset); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdDrawClusterIndirectHUAWEI\n"; } + device_dispatch_table(commandBuffer)->CmdDrawClusterIndirectHUAWEI(commandBuffer, buffer, offset); } template VKAPI_ATTR void VKAPI_CALL vkSetDeviceMemoryPriorityEXT(VkDevice device, VkDeviceMemory memory, float priority) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkSetDeviceMemoryPriorityEXT", "device, memory, priority", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkSetDeviceMemoryPriorityEXT(ApiDumpInstance::current(), device, memory, priority); - } - } - device_dispatch_table(device)->SetDeviceMemoryPriorityEXT(device, memory, priority); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkSetDeviceMemoryPriorityEXT(ApiDumpInstance::current(), device, memory, priority); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkSetDeviceMemoryPriorityEXT\n"; } + device_dispatch_table(device)->SetDeviceMemoryPriorityEXT(device, memory, priority); } template VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutHostMappingInfoVALVE(VkDevice device, const VkDescriptorSetBindingReferenceVALVE* pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDescriptorSetLayoutHostMappingInfoVALVE", "device, pBindingReference, pHostMapping", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDescriptorSetLayoutHostMappingInfoVALVE(ApiDumpInstance::current(), device, pBindingReference, pHostMapping); - } - } - device_dispatch_table(device)->GetDescriptorSetLayoutHostMappingInfoVALVE(device, pBindingReference, pHostMapping); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDescriptorSetLayoutHostMappingInfoVALVE(ApiDumpInstance::current(), device, pBindingReference, pHostMapping); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDescriptorSetLayoutHostMappingInfoVALVE\n"; } + device_dispatch_table(device)->GetDescriptorSetLayoutHostMappingInfoVALVE(device, pBindingReference, pHostMapping); } template VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetHostMappingVALVE(VkDevice device, VkDescriptorSet descriptorSet, void** ppData) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDescriptorSetHostMappingVALVE", "device, descriptorSet, ppData", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDescriptorSetHostMappingVALVE(ApiDumpInstance::current(), device, descriptorSet, ppData); - } - } - device_dispatch_table(device)->GetDescriptorSetHostMappingVALVE(device, descriptorSet, ppData); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDescriptorSetHostMappingVALVE(ApiDumpInstance::current(), device, descriptorSet, ppData); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDescriptorSetHostMappingVALVE\n"; } + device_dispatch_table(device)->GetDescriptorSetHostMappingVALVE(device, descriptorSet, ppData); } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdCopyMemoryIndirectNV", "commandBuffer, copyBufferAddress, copyCount, stride", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyMemoryIndirectNV(ApiDumpInstance::current(), commandBuffer, copyBufferAddress, copyCount, stride); - } - } - device_dispatch_table(commandBuffer)->CmdCopyMemoryIndirectNV(commandBuffer, copyBufferAddress, copyCount, stride); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyMemoryIndirectNV(ApiDumpInstance::current(), commandBuffer, copyBufferAddress, copyCount, stride); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdCopyMemoryIndirectNV\n"; } + device_dispatch_table(commandBuffer)->CmdCopyMemoryIndirectNV(commandBuffer, copyBufferAddress, copyCount, stride); } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToImageIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VkImage dstImage, VkImageLayout dstImageLayout, const VkImageSubresourceLayers* pImageSubresources) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdCopyMemoryToImageIndirectNV", "commandBuffer, copyBufferAddress, copyCount, stride, dstImage, dstImageLayout, pImageSubresources", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyMemoryToImageIndirectNV(ApiDumpInstance::current(), commandBuffer, copyBufferAddress, copyCount, stride, dstImage, dstImageLayout, pImageSubresources); - } - } - device_dispatch_table(commandBuffer)->CmdCopyMemoryToImageIndirectNV(commandBuffer, copyBufferAddress, copyCount, stride, dstImage, dstImageLayout, pImageSubresources); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyMemoryToImageIndirectNV(ApiDumpInstance::current(), commandBuffer, copyBufferAddress, copyCount, stride, dstImage, dstImageLayout, pImageSubresources); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdCopyMemoryToImageIndirectNV\n"; } + device_dispatch_table(commandBuffer)->CmdCopyMemoryToImageIndirectNV(commandBuffer, copyBufferAddress, copyCount, stride, dstImage, dstImageLayout, pImageSubresources); } template VKAPI_ATTR void VKAPI_CALL vkCmdDecompressMemoryNV(VkCommandBuffer commandBuffer, uint32_t decompressRegionCount, const VkDecompressMemoryRegionNV* pDecompressMemoryRegions) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdDecompressMemoryNV", "commandBuffer, decompressRegionCount, pDecompressMemoryRegions", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDecompressMemoryNV(ApiDumpInstance::current(), commandBuffer, decompressRegionCount, pDecompressMemoryRegions); - } - } - device_dispatch_table(commandBuffer)->CmdDecompressMemoryNV(commandBuffer, decompressRegionCount, pDecompressMemoryRegions); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDecompressMemoryNV(ApiDumpInstance::current(), commandBuffer, decompressRegionCount, pDecompressMemoryRegions); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdDecompressMemoryNV\n"; } + device_dispatch_table(commandBuffer)->CmdDecompressMemoryNV(commandBuffer, decompressRegionCount, pDecompressMemoryRegions); } template VKAPI_ATTR void VKAPI_CALL vkCmdDecompressMemoryIndirectCountNV(VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t stride) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdDecompressMemoryIndirectCountNV", "commandBuffer, indirectCommandsAddress, indirectCommandsCountAddress, stride", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDecompressMemoryIndirectCountNV(ApiDumpInstance::current(), commandBuffer, indirectCommandsAddress, indirectCommandsCountAddress, stride); - } - } - device_dispatch_table(commandBuffer)->CmdDecompressMemoryIndirectCountNV(commandBuffer, indirectCommandsAddress, indirectCommandsCountAddress, stride); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDecompressMemoryIndirectCountNV(ApiDumpInstance::current(), commandBuffer, indirectCommandsAddress, indirectCommandsCountAddress, stride); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdDecompressMemoryIndirectCountNV\n"; } + device_dispatch_table(commandBuffer)->CmdDecompressMemoryIndirectCountNV(commandBuffer, indirectCommandsAddress, indirectCommandsCountAddress, stride); } template VKAPI_ATTR void VKAPI_CALL vkGetPipelineIndirectMemoryRequirementsNV(VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo, VkMemoryRequirements2* pMemoryRequirements) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPipelineIndirectMemoryRequirementsNV", "device, pCreateInfo, pMemoryRequirements", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPipelineIndirectMemoryRequirementsNV(ApiDumpInstance::current(), device, pCreateInfo, pMemoryRequirements); - } - } - device_dispatch_table(device)->GetPipelineIndirectMemoryRequirementsNV(device, pCreateInfo, pMemoryRequirements); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPipelineIndirectMemoryRequirementsNV(ApiDumpInstance::current(), device, pCreateInfo, pMemoryRequirements); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPipelineIndirectMemoryRequirementsNV\n"; } + device_dispatch_table(device)->GetPipelineIndirectMemoryRequirementsNV(device, pCreateInfo, pMemoryRequirements); } template VKAPI_ATTR void VKAPI_CALL vkCmdUpdatePipelineIndirectBufferNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdUpdatePipelineIndirectBufferNV", "commandBuffer, pipelineBindPoint, pipeline", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdUpdatePipelineIndirectBufferNV(ApiDumpInstance::current(), commandBuffer, pipelineBindPoint, pipeline); - } - } - device_dispatch_table(commandBuffer)->CmdUpdatePipelineIndirectBufferNV(commandBuffer, pipelineBindPoint, pipeline); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdUpdatePipelineIndirectBufferNV(ApiDumpInstance::current(), commandBuffer, pipelineBindPoint, pipeline); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdUpdatePipelineIndirectBufferNV\n"; } + device_dispatch_table(commandBuffer)->CmdUpdatePipelineIndirectBufferNV(commandBuffer, pipelineBindPoint, pipeline); } template VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetPipelineIndirectDeviceAddressNV(VkDevice device, const VkPipelineIndirectDeviceAddressInfoNV* pInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPipelineIndirectDeviceAddressNV", "device, pInfo", "VkDeviceAddress"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPipelineIndirectDeviceAddressNV(ApiDumpInstance::current(), device, pInfo); - } - } - VkDeviceAddress result = device_dispatch_table(device)->GetPipelineIndirectDeviceAddressNV(device, pInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkDeviceAddress", result, dump_return_value_VkDeviceAddress); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPipelineIndirectDeviceAddressNV(ApiDumpInstance::current(), device, pInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPipelineIndirectDeviceAddressNV\n"; } + VkDeviceAddress result = device_dispatch_table(device)->GetPipelineIndirectDeviceAddressNV(device, pInfo); return result; } #if defined(VK_USE_PLATFORM_OHOS) @@ -12912,42 +6160,20 @@ template VKAPI_ATTR VkResult VKAPI_CALL vkGetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer, VkNativeBufferPropertiesOHOS* pProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetNativeBufferPropertiesOHOS", "device, buffer, pProperties", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetNativeBufferPropertiesOHOS(ApiDumpInstance::current(), device, buffer, pProperties); - } - } - VkResult result = device_dispatch_table(device)->GetNativeBufferPropertiesOHOS(device, buffer, pProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetNativeBufferPropertiesOHOS(ApiDumpInstance::current(), device, buffer, pProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetNativeBufferPropertiesOHOS\n"; } + VkResult result = device_dispatch_table(device)->GetNativeBufferPropertiesOHOS(device, buffer, pProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, struct OH_NativeBuffer** pBuffer) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetMemoryNativeBufferOHOS", "device, pInfo, pBuffer", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetMemoryNativeBufferOHOS(ApiDumpInstance::current(), device, pInfo, pBuffer); - } - } - VkResult result = device_dispatch_table(device)->GetMemoryNativeBufferOHOS(device, pInfo, pBuffer); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetMemoryNativeBufferOHOS(ApiDumpInstance::current(), device, pInfo, pBuffer); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetMemoryNativeBufferOHOS\n"; } + VkResult result = device_dispatch_table(device)->GetMemoryNativeBufferOHOS(device, pInfo, pBuffer); return result; } #endif // VK_USE_PLATFORM_OHOS @@ -12955,1430 +6181,679 @@ template VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClampEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetDepthClampEnableEXT", "commandBuffer, depthClampEnable", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDepthClampEnableEXT(ApiDumpInstance::current(), commandBuffer, depthClampEnable); - } - } - device_dispatch_table(commandBuffer)->CmdSetDepthClampEnableEXT(commandBuffer, depthClampEnable); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDepthClampEnableEXT(ApiDumpInstance::current(), commandBuffer, depthClampEnable); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetDepthClampEnableEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetDepthClampEnableEXT(commandBuffer, depthClampEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetPolygonModeEXT(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetPolygonModeEXT", "commandBuffer, polygonMode", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetPolygonModeEXT(ApiDumpInstance::current(), commandBuffer, polygonMode); - } - } - device_dispatch_table(commandBuffer)->CmdSetPolygonModeEXT(commandBuffer, polygonMode); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetPolygonModeEXT(ApiDumpInstance::current(), commandBuffer, polygonMode); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetPolygonModeEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetPolygonModeEXT(commandBuffer, polygonMode); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizationSamplesEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetRasterizationSamplesEXT", "commandBuffer, rasterizationSamples", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetRasterizationSamplesEXT(ApiDumpInstance::current(), commandBuffer, rasterizationSamples); - } - } - device_dispatch_table(commandBuffer)->CmdSetRasterizationSamplesEXT(commandBuffer, rasterizationSamples); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetRasterizationSamplesEXT(ApiDumpInstance::current(), commandBuffer, rasterizationSamples); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetRasterizationSamplesEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetRasterizationSamplesEXT(commandBuffer, rasterizationSamples); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleMaskEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask* pSampleMask) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetSampleMaskEXT", "commandBuffer, samples, pSampleMask", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetSampleMaskEXT(ApiDumpInstance::current(), commandBuffer, samples, pSampleMask); - } - } - device_dispatch_table(commandBuffer)->CmdSetSampleMaskEXT(commandBuffer, samples, pSampleMask); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetSampleMaskEXT(ApiDumpInstance::current(), commandBuffer, samples, pSampleMask); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetSampleMaskEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetSampleMaskEXT(commandBuffer, samples, pSampleMask); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetAlphaToCoverageEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetAlphaToCoverageEnableEXT", "commandBuffer, alphaToCoverageEnable", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetAlphaToCoverageEnableEXT(ApiDumpInstance::current(), commandBuffer, alphaToCoverageEnable); - } - } - device_dispatch_table(commandBuffer)->CmdSetAlphaToCoverageEnableEXT(commandBuffer, alphaToCoverageEnable); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetAlphaToCoverageEnableEXT(ApiDumpInstance::current(), commandBuffer, alphaToCoverageEnable); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetAlphaToCoverageEnableEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetAlphaToCoverageEnableEXT(commandBuffer, alphaToCoverageEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetAlphaToOneEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetAlphaToOneEnableEXT", "commandBuffer, alphaToOneEnable", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetAlphaToOneEnableEXT(ApiDumpInstance::current(), commandBuffer, alphaToOneEnable); - } - } - device_dispatch_table(commandBuffer)->CmdSetAlphaToOneEnableEXT(commandBuffer, alphaToOneEnable); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetAlphaToOneEnableEXT(ApiDumpInstance::current(), commandBuffer, alphaToOneEnable); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetAlphaToOneEnableEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetAlphaToOneEnableEXT(commandBuffer, alphaToOneEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetLogicOpEnableEXT(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetLogicOpEnableEXT", "commandBuffer, logicOpEnable", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetLogicOpEnableEXT(ApiDumpInstance::current(), commandBuffer, logicOpEnable); - } - } - device_dispatch_table(commandBuffer)->CmdSetLogicOpEnableEXT(commandBuffer, logicOpEnable); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetLogicOpEnableEXT(ApiDumpInstance::current(), commandBuffer, logicOpEnable); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetLogicOpEnableEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetLogicOpEnableEXT(commandBuffer, logicOpEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetColorBlendEnableEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32* pColorBlendEnables) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetColorBlendEnableEXT", "commandBuffer, firstAttachment, attachmentCount, pColorBlendEnables", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetColorBlendEnableEXT(ApiDumpInstance::current(), commandBuffer, firstAttachment, attachmentCount, pColorBlendEnables); - } - } - device_dispatch_table(commandBuffer)->CmdSetColorBlendEnableEXT(commandBuffer, firstAttachment, attachmentCount, pColorBlendEnables); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetColorBlendEnableEXT(ApiDumpInstance::current(), commandBuffer, firstAttachment, attachmentCount, pColorBlendEnables); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetColorBlendEnableEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetColorBlendEnableEXT(commandBuffer, firstAttachment, attachmentCount, pColorBlendEnables); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetColorBlendEquationEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT* pColorBlendEquations) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetColorBlendEquationEXT", "commandBuffer, firstAttachment, attachmentCount, pColorBlendEquations", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetColorBlendEquationEXT(ApiDumpInstance::current(), commandBuffer, firstAttachment, attachmentCount, pColorBlendEquations); - } - } - device_dispatch_table(commandBuffer)->CmdSetColorBlendEquationEXT(commandBuffer, firstAttachment, attachmentCount, pColorBlendEquations); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetColorBlendEquationEXT(ApiDumpInstance::current(), commandBuffer, firstAttachment, attachmentCount, pColorBlendEquations); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetColorBlendEquationEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetColorBlendEquationEXT(commandBuffer, firstAttachment, attachmentCount, pColorBlendEquations); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetColorWriteMaskEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags* pColorWriteMasks) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetColorWriteMaskEXT", "commandBuffer, firstAttachment, attachmentCount, pColorWriteMasks", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetColorWriteMaskEXT(ApiDumpInstance::current(), commandBuffer, firstAttachment, attachmentCount, pColorWriteMasks); - } - } - device_dispatch_table(commandBuffer)->CmdSetColorWriteMaskEXT(commandBuffer, firstAttachment, attachmentCount, pColorWriteMasks); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetColorWriteMaskEXT(ApiDumpInstance::current(), commandBuffer, firstAttachment, attachmentCount, pColorWriteMasks); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetColorWriteMaskEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetColorWriteMaskEXT(commandBuffer, firstAttachment, attachmentCount, pColorWriteMasks); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetTessellationDomainOriginEXT(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetTessellationDomainOriginEXT", "commandBuffer, domainOrigin", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetTessellationDomainOriginEXT(ApiDumpInstance::current(), commandBuffer, domainOrigin); - } - } - device_dispatch_table(commandBuffer)->CmdSetTessellationDomainOriginEXT(commandBuffer, domainOrigin); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetTessellationDomainOriginEXT(ApiDumpInstance::current(), commandBuffer, domainOrigin); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetTessellationDomainOriginEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetTessellationDomainOriginEXT(commandBuffer, domainOrigin); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizationStreamEXT(VkCommandBuffer commandBuffer, uint32_t rasterizationStream) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetRasterizationStreamEXT", "commandBuffer, rasterizationStream", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetRasterizationStreamEXT(ApiDumpInstance::current(), commandBuffer, rasterizationStream); - } - } - device_dispatch_table(commandBuffer)->CmdSetRasterizationStreamEXT(commandBuffer, rasterizationStream); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetRasterizationStreamEXT(ApiDumpInstance::current(), commandBuffer, rasterizationStream); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetRasterizationStreamEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetRasterizationStreamEXT(commandBuffer, rasterizationStream); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetConservativeRasterizationModeEXT(VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetConservativeRasterizationModeEXT", "commandBuffer, conservativeRasterizationMode", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetConservativeRasterizationModeEXT(ApiDumpInstance::current(), commandBuffer, conservativeRasterizationMode); - } - } - device_dispatch_table(commandBuffer)->CmdSetConservativeRasterizationModeEXT(commandBuffer, conservativeRasterizationMode); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetConservativeRasterizationModeEXT(ApiDumpInstance::current(), commandBuffer, conservativeRasterizationMode); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetConservativeRasterizationModeEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetConservativeRasterizationModeEXT(commandBuffer, conservativeRasterizationMode); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetExtraPrimitiveOverestimationSizeEXT(VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetExtraPrimitiveOverestimationSizeEXT", "commandBuffer, extraPrimitiveOverestimationSize", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetExtraPrimitiveOverestimationSizeEXT(ApiDumpInstance::current(), commandBuffer, extraPrimitiveOverestimationSize); - } - } - device_dispatch_table(commandBuffer)->CmdSetExtraPrimitiveOverestimationSizeEXT(commandBuffer, extraPrimitiveOverestimationSize); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetExtraPrimitiveOverestimationSizeEXT(ApiDumpInstance::current(), commandBuffer, extraPrimitiveOverestimationSize); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetExtraPrimitiveOverestimationSizeEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetExtraPrimitiveOverestimationSizeEXT(commandBuffer, extraPrimitiveOverestimationSize); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClipEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetDepthClipEnableEXT", "commandBuffer, depthClipEnable", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDepthClipEnableEXT(ApiDumpInstance::current(), commandBuffer, depthClipEnable); - } - } - device_dispatch_table(commandBuffer)->CmdSetDepthClipEnableEXT(commandBuffer, depthClipEnable); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDepthClipEnableEXT(ApiDumpInstance::current(), commandBuffer, depthClipEnable); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetDepthClipEnableEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetDepthClipEnableEXT(commandBuffer, depthClipEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEnableEXT(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetSampleLocationsEnableEXT", "commandBuffer, sampleLocationsEnable", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetSampleLocationsEnableEXT(ApiDumpInstance::current(), commandBuffer, sampleLocationsEnable); - } - } - device_dispatch_table(commandBuffer)->CmdSetSampleLocationsEnableEXT(commandBuffer, sampleLocationsEnable); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetSampleLocationsEnableEXT(ApiDumpInstance::current(), commandBuffer, sampleLocationsEnable); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetSampleLocationsEnableEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetSampleLocationsEnableEXT(commandBuffer, sampleLocationsEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetColorBlendAdvancedEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT* pColorBlendAdvanced) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetColorBlendAdvancedEXT", "commandBuffer, firstAttachment, attachmentCount, pColorBlendAdvanced", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetColorBlendAdvancedEXT(ApiDumpInstance::current(), commandBuffer, firstAttachment, attachmentCount, pColorBlendAdvanced); - } - } - device_dispatch_table(commandBuffer)->CmdSetColorBlendAdvancedEXT(commandBuffer, firstAttachment, attachmentCount, pColorBlendAdvanced); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetColorBlendAdvancedEXT(ApiDumpInstance::current(), commandBuffer, firstAttachment, attachmentCount, pColorBlendAdvanced); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetColorBlendAdvancedEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetColorBlendAdvancedEXT(commandBuffer, firstAttachment, attachmentCount, pColorBlendAdvanced); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetProvokingVertexModeEXT(VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetProvokingVertexModeEXT", "commandBuffer, provokingVertexMode", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetProvokingVertexModeEXT(ApiDumpInstance::current(), commandBuffer, provokingVertexMode); - } - } - device_dispatch_table(commandBuffer)->CmdSetProvokingVertexModeEXT(commandBuffer, provokingVertexMode); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetProvokingVertexModeEXT(ApiDumpInstance::current(), commandBuffer, provokingVertexMode); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetProvokingVertexModeEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetProvokingVertexModeEXT(commandBuffer, provokingVertexMode); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetLineRasterizationModeEXT(VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetLineRasterizationModeEXT", "commandBuffer, lineRasterizationMode", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetLineRasterizationModeEXT(ApiDumpInstance::current(), commandBuffer, lineRasterizationMode); - } - } - device_dispatch_table(commandBuffer)->CmdSetLineRasterizationModeEXT(commandBuffer, lineRasterizationMode); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetLineRasterizationModeEXT(ApiDumpInstance::current(), commandBuffer, lineRasterizationMode); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetLineRasterizationModeEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetLineRasterizationModeEXT(commandBuffer, lineRasterizationMode); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetLineStippleEnableEXT", "commandBuffer, stippledLineEnable", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetLineStippleEnableEXT(ApiDumpInstance::current(), commandBuffer, stippledLineEnable); - } - } - device_dispatch_table(commandBuffer)->CmdSetLineStippleEnableEXT(commandBuffer, stippledLineEnable); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetLineStippleEnableEXT(ApiDumpInstance::current(), commandBuffer, stippledLineEnable); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetLineStippleEnableEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetLineStippleEnableEXT(commandBuffer, stippledLineEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClipNegativeOneToOneEXT(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetDepthClipNegativeOneToOneEXT", "commandBuffer, negativeOneToOne", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDepthClipNegativeOneToOneEXT(ApiDumpInstance::current(), commandBuffer, negativeOneToOne); - } - } - device_dispatch_table(commandBuffer)->CmdSetDepthClipNegativeOneToOneEXT(commandBuffer, negativeOneToOne); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDepthClipNegativeOneToOneEXT(ApiDumpInstance::current(), commandBuffer, negativeOneToOne); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetDepthClipNegativeOneToOneEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetDepthClipNegativeOneToOneEXT(commandBuffer, negativeOneToOne); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingEnableNV(VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetViewportWScalingEnableNV", "commandBuffer, viewportWScalingEnable", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetViewportWScalingEnableNV(ApiDumpInstance::current(), commandBuffer, viewportWScalingEnable); - } - } - device_dispatch_table(commandBuffer)->CmdSetViewportWScalingEnableNV(commandBuffer, viewportWScalingEnable); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetViewportWScalingEnableNV(ApiDumpInstance::current(), commandBuffer, viewportWScalingEnable); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetViewportWScalingEnableNV\n"; } + device_dispatch_table(commandBuffer)->CmdSetViewportWScalingEnableNV(commandBuffer, viewportWScalingEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportSwizzleNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV* pViewportSwizzles) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetViewportSwizzleNV", "commandBuffer, firstViewport, viewportCount, pViewportSwizzles", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetViewportSwizzleNV(ApiDumpInstance::current(), commandBuffer, firstViewport, viewportCount, pViewportSwizzles); - } - } - device_dispatch_table(commandBuffer)->CmdSetViewportSwizzleNV(commandBuffer, firstViewport, viewportCount, pViewportSwizzles); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetViewportSwizzleNV(ApiDumpInstance::current(), commandBuffer, firstViewport, viewportCount, pViewportSwizzles); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetViewportSwizzleNV\n"; } + device_dispatch_table(commandBuffer)->CmdSetViewportSwizzleNV(commandBuffer, firstViewport, viewportCount, pViewportSwizzles); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageToColorEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetCoverageToColorEnableNV", "commandBuffer, coverageToColorEnable", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetCoverageToColorEnableNV(ApiDumpInstance::current(), commandBuffer, coverageToColorEnable); - } - } - device_dispatch_table(commandBuffer)->CmdSetCoverageToColorEnableNV(commandBuffer, coverageToColorEnable); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetCoverageToColorEnableNV(ApiDumpInstance::current(), commandBuffer, coverageToColorEnable); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetCoverageToColorEnableNV\n"; } + device_dispatch_table(commandBuffer)->CmdSetCoverageToColorEnableNV(commandBuffer, coverageToColorEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageToColorLocationNV(VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetCoverageToColorLocationNV", "commandBuffer, coverageToColorLocation", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetCoverageToColorLocationNV(ApiDumpInstance::current(), commandBuffer, coverageToColorLocation); - } - } - device_dispatch_table(commandBuffer)->CmdSetCoverageToColorLocationNV(commandBuffer, coverageToColorLocation); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetCoverageToColorLocationNV(ApiDumpInstance::current(), commandBuffer, coverageToColorLocation); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetCoverageToColorLocationNV\n"; } + device_dispatch_table(commandBuffer)->CmdSetCoverageToColorLocationNV(commandBuffer, coverageToColorLocation); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageModulationModeNV(VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetCoverageModulationModeNV", "commandBuffer, coverageModulationMode", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetCoverageModulationModeNV(ApiDumpInstance::current(), commandBuffer, coverageModulationMode); - } - } - device_dispatch_table(commandBuffer)->CmdSetCoverageModulationModeNV(commandBuffer, coverageModulationMode); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetCoverageModulationModeNV(ApiDumpInstance::current(), commandBuffer, coverageModulationMode); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetCoverageModulationModeNV\n"; } + device_dispatch_table(commandBuffer)->CmdSetCoverageModulationModeNV(commandBuffer, coverageModulationMode); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageModulationTableEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetCoverageModulationTableEnableNV", "commandBuffer, coverageModulationTableEnable", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetCoverageModulationTableEnableNV(ApiDumpInstance::current(), commandBuffer, coverageModulationTableEnable); - } - } - device_dispatch_table(commandBuffer)->CmdSetCoverageModulationTableEnableNV(commandBuffer, coverageModulationTableEnable); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetCoverageModulationTableEnableNV(ApiDumpInstance::current(), commandBuffer, coverageModulationTableEnable); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetCoverageModulationTableEnableNV\n"; } + device_dispatch_table(commandBuffer)->CmdSetCoverageModulationTableEnableNV(commandBuffer, coverageModulationTableEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageModulationTableNV(VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float* pCoverageModulationTable) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetCoverageModulationTableNV", "commandBuffer, coverageModulationTableCount, pCoverageModulationTable", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetCoverageModulationTableNV(ApiDumpInstance::current(), commandBuffer, coverageModulationTableCount, pCoverageModulationTable); - } - } - device_dispatch_table(commandBuffer)->CmdSetCoverageModulationTableNV(commandBuffer, coverageModulationTableCount, pCoverageModulationTable); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetCoverageModulationTableNV(ApiDumpInstance::current(), commandBuffer, coverageModulationTableCount, pCoverageModulationTable); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetCoverageModulationTableNV\n"; } + device_dispatch_table(commandBuffer)->CmdSetCoverageModulationTableNV(commandBuffer, coverageModulationTableCount, pCoverageModulationTable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetShadingRateImageEnableNV(VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetShadingRateImageEnableNV", "commandBuffer, shadingRateImageEnable", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetShadingRateImageEnableNV(ApiDumpInstance::current(), commandBuffer, shadingRateImageEnable); - } - } - device_dispatch_table(commandBuffer)->CmdSetShadingRateImageEnableNV(commandBuffer, shadingRateImageEnable); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetShadingRateImageEnableNV(ApiDumpInstance::current(), commandBuffer, shadingRateImageEnable); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetShadingRateImageEnableNV\n"; } + device_dispatch_table(commandBuffer)->CmdSetShadingRateImageEnableNV(commandBuffer, shadingRateImageEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetRepresentativeFragmentTestEnableNV(VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetRepresentativeFragmentTestEnableNV", "commandBuffer, representativeFragmentTestEnable", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetRepresentativeFragmentTestEnableNV(ApiDumpInstance::current(), commandBuffer, representativeFragmentTestEnable); - } - } - device_dispatch_table(commandBuffer)->CmdSetRepresentativeFragmentTestEnableNV(commandBuffer, representativeFragmentTestEnable); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetRepresentativeFragmentTestEnableNV(ApiDumpInstance::current(), commandBuffer, representativeFragmentTestEnable); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetRepresentativeFragmentTestEnableNV\n"; } + device_dispatch_table(commandBuffer)->CmdSetRepresentativeFragmentTestEnableNV(commandBuffer, representativeFragmentTestEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageReductionModeNV(VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetCoverageReductionModeNV", "commandBuffer, coverageReductionMode", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetCoverageReductionModeNV(ApiDumpInstance::current(), commandBuffer, coverageReductionMode); - } - } - device_dispatch_table(commandBuffer)->CmdSetCoverageReductionModeNV(commandBuffer, coverageReductionMode); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetCoverageReductionModeNV(ApiDumpInstance::current(), commandBuffer, coverageReductionMode); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetCoverageReductionModeNV\n"; } + device_dispatch_table(commandBuffer)->CmdSetCoverageReductionModeNV(commandBuffer, coverageReductionMode); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateTensorARM(VkDevice device, const VkTensorCreateInfoARM* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkTensorARM* pTensor) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateTensorARM", "device, pCreateInfo, pAllocator, pTensor", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateTensorARM(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pTensor); - } - } - VkResult result = device_dispatch_table(device)->CreateTensorARM(device, pCreateInfo, pAllocator, pTensor); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateTensorARM(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pTensor); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateTensorARM\n"; } + VkResult result = device_dispatch_table(device)->CreateTensorARM(device, pCreateInfo, pAllocator, pTensor); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyTensorARM(VkDevice device, VkTensorARM tensor, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyTensorARM", "device, tensor, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyTensorARM(ApiDumpInstance::current(), device, tensor, pAllocator); - } - } - device_dispatch_table(device)->DestroyTensorARM(device, tensor, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyTensorARM(ApiDumpInstance::current(), device, tensor, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyTensorARM\n"; } + device_dispatch_table(device)->DestroyTensorARM(device, tensor, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateTensorViewARM(VkDevice device, const VkTensorViewCreateInfoARM* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkTensorViewARM* pView) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateTensorViewARM", "device, pCreateInfo, pAllocator, pView", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateTensorViewARM(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pView); - } - } - VkResult result = device_dispatch_table(device)->CreateTensorViewARM(device, pCreateInfo, pAllocator, pView); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateTensorViewARM(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pView); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateTensorViewARM\n"; } + VkResult result = device_dispatch_table(device)->CreateTensorViewARM(device, pCreateInfo, pAllocator, pView); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyTensorViewARM(VkDevice device, VkTensorViewARM tensorView, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyTensorViewARM", "device, tensorView, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyTensorViewARM(ApiDumpInstance::current(), device, tensorView, pAllocator); - } - } - device_dispatch_table(device)->DestroyTensorViewARM(device, tensorView, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyTensorViewARM(ApiDumpInstance::current(), device, tensorView, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyTensorViewARM\n"; } + device_dispatch_table(device)->DestroyTensorViewARM(device, tensorView, pAllocator); } template VKAPI_ATTR void VKAPI_CALL vkGetTensorMemoryRequirementsARM(VkDevice device, const VkTensorMemoryRequirementsInfoARM* pInfo, VkMemoryRequirements2* pMemoryRequirements) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetTensorMemoryRequirementsARM", "device, pInfo, pMemoryRequirements", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetTensorMemoryRequirementsARM(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements); - } - } - device_dispatch_table(device)->GetTensorMemoryRequirementsARM(device, pInfo, pMemoryRequirements); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetTensorMemoryRequirementsARM(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetTensorMemoryRequirementsARM\n"; } + device_dispatch_table(device)->GetTensorMemoryRequirementsARM(device, pInfo, pMemoryRequirements); } template VKAPI_ATTR VkResult VKAPI_CALL vkBindTensorMemoryARM(VkDevice device, uint32_t bindInfoCount, const VkBindTensorMemoryInfoARM* pBindInfos) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkBindTensorMemoryARM", "device, bindInfoCount, pBindInfos", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkBindTensorMemoryARM(ApiDumpInstance::current(), device, bindInfoCount, pBindInfos); - } - } - VkResult result = device_dispatch_table(device)->BindTensorMemoryARM(device, bindInfoCount, pBindInfos); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkBindTensorMemoryARM(ApiDumpInstance::current(), device, bindInfoCount, pBindInfos); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkBindTensorMemoryARM\n"; } + VkResult result = device_dispatch_table(device)->BindTensorMemoryARM(device, bindInfoCount, pBindInfos); return result; } template VKAPI_ATTR void VKAPI_CALL vkGetDeviceTensorMemoryRequirementsARM(VkDevice device, const VkDeviceTensorMemoryRequirementsARM* pInfo, VkMemoryRequirements2* pMemoryRequirements) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDeviceTensorMemoryRequirementsARM", "device, pInfo, pMemoryRequirements", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceTensorMemoryRequirementsARM(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements); - } - } - device_dispatch_table(device)->GetDeviceTensorMemoryRequirementsARM(device, pInfo, pMemoryRequirements); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceTensorMemoryRequirementsARM(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDeviceTensorMemoryRequirementsARM\n"; } + device_dispatch_table(device)->GetDeviceTensorMemoryRequirementsARM(device, pInfo, pMemoryRequirements); } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyTensorARM(VkCommandBuffer commandBuffer, const VkCopyTensorInfoARM* pCopyTensorInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdCopyTensorARM", "commandBuffer, pCopyTensorInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyTensorARM(ApiDumpInstance::current(), commandBuffer, pCopyTensorInfo); - } - } - device_dispatch_table(commandBuffer)->CmdCopyTensorARM(commandBuffer, pCopyTensorInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyTensorARM(ApiDumpInstance::current(), commandBuffer, pCopyTensorInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdCopyTensorARM\n"; } + device_dispatch_table(commandBuffer)->CmdCopyTensorARM(commandBuffer, pCopyTensorInfo); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetTensorOpaqueCaptureDescriptorDataARM(VkDevice device, const VkTensorCaptureDescriptorDataInfoARM* pInfo, void* pData) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetTensorOpaqueCaptureDescriptorDataARM", "device, pInfo, pData", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetTensorOpaqueCaptureDescriptorDataARM(ApiDumpInstance::current(), device, pInfo, pData); - } - } - VkResult result = device_dispatch_table(device)->GetTensorOpaqueCaptureDescriptorDataARM(device, pInfo, pData); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetTensorOpaqueCaptureDescriptorDataARM(ApiDumpInstance::current(), device, pInfo, pData); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetTensorOpaqueCaptureDescriptorDataARM\n"; } + VkResult result = device_dispatch_table(device)->GetTensorOpaqueCaptureDescriptorDataARM(device, pInfo, pData); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetTensorViewOpaqueCaptureDescriptorDataARM(VkDevice device, const VkTensorViewCaptureDescriptorDataInfoARM* pInfo, void* pData) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetTensorViewOpaqueCaptureDescriptorDataARM", "device, pInfo, pData", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetTensorViewOpaqueCaptureDescriptorDataARM(ApiDumpInstance::current(), device, pInfo, pData); - } - } - VkResult result = device_dispatch_table(device)->GetTensorViewOpaqueCaptureDescriptorDataARM(device, pInfo, pData); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetTensorViewOpaqueCaptureDescriptorDataARM(ApiDumpInstance::current(), device, pInfo, pData); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetTensorViewOpaqueCaptureDescriptorDataARM\n"; } + VkResult result = device_dispatch_table(device)->GetTensorViewOpaqueCaptureDescriptorDataARM(device, pInfo, pData); return result; } template VKAPI_ATTR void VKAPI_CALL vkGetShaderModuleIdentifierEXT(VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT* pIdentifier) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetShaderModuleIdentifierEXT", "device, shaderModule, pIdentifier", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetShaderModuleIdentifierEXT(ApiDumpInstance::current(), device, shaderModule, pIdentifier); - } - } - device_dispatch_table(device)->GetShaderModuleIdentifierEXT(device, shaderModule, pIdentifier); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetShaderModuleIdentifierEXT(ApiDumpInstance::current(), device, shaderModule, pIdentifier); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetShaderModuleIdentifierEXT\n"; } + device_dispatch_table(device)->GetShaderModuleIdentifierEXT(device, shaderModule, pIdentifier); } template VKAPI_ATTR void VKAPI_CALL vkGetShaderModuleCreateInfoIdentifierEXT(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModuleIdentifierEXT* pIdentifier) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetShaderModuleCreateInfoIdentifierEXT", "device, pCreateInfo, pIdentifier", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetShaderModuleCreateInfoIdentifierEXT(ApiDumpInstance::current(), device, pCreateInfo, pIdentifier); - } - } - device_dispatch_table(device)->GetShaderModuleCreateInfoIdentifierEXT(device, pCreateInfo, pIdentifier); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetShaderModuleCreateInfoIdentifierEXT(ApiDumpInstance::current(), device, pCreateInfo, pIdentifier); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetShaderModuleCreateInfoIdentifierEXT\n"; } + device_dispatch_table(device)->GetShaderModuleCreateInfoIdentifierEXT(device, pCreateInfo, pIdentifier); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateOpticalFlowSessionNV(VkDevice device, const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkOpticalFlowSessionNV* pSession) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateOpticalFlowSessionNV", "device, pCreateInfo, pAllocator, pSession", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateOpticalFlowSessionNV(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pSession); - } - } - VkResult result = device_dispatch_table(device)->CreateOpticalFlowSessionNV(device, pCreateInfo, pAllocator, pSession); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateOpticalFlowSessionNV(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pSession); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateOpticalFlowSessionNV\n"; } + VkResult result = device_dispatch_table(device)->CreateOpticalFlowSessionNV(device, pCreateInfo, pAllocator, pSession); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyOpticalFlowSessionNV(VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyOpticalFlowSessionNV", "device, session, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyOpticalFlowSessionNV(ApiDumpInstance::current(), device, session, pAllocator); - } - } - device_dispatch_table(device)->DestroyOpticalFlowSessionNV(device, session, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyOpticalFlowSessionNV(ApiDumpInstance::current(), device, session, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyOpticalFlowSessionNV\n"; } + device_dispatch_table(device)->DestroyOpticalFlowSessionNV(device, session, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkBindOpticalFlowSessionImageNV(VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkBindOpticalFlowSessionImageNV", "device, session, bindingPoint, view, layout", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkBindOpticalFlowSessionImageNV(ApiDumpInstance::current(), device, session, bindingPoint, view, layout); - } - } - VkResult result = device_dispatch_table(device)->BindOpticalFlowSessionImageNV(device, session, bindingPoint, view, layout); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkBindOpticalFlowSessionImageNV(ApiDumpInstance::current(), device, session, bindingPoint, view, layout); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkBindOpticalFlowSessionImageNV\n"; } + VkResult result = device_dispatch_table(device)->BindOpticalFlowSessionImageNV(device, session, bindingPoint, view, layout); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdOpticalFlowExecuteNV(VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV* pExecuteInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdOpticalFlowExecuteNV", "commandBuffer, session, pExecuteInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdOpticalFlowExecuteNV(ApiDumpInstance::current(), commandBuffer, session, pExecuteInfo); - } - } - device_dispatch_table(commandBuffer)->CmdOpticalFlowExecuteNV(commandBuffer, session, pExecuteInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdOpticalFlowExecuteNV(ApiDumpInstance::current(), commandBuffer, session, pExecuteInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdOpticalFlowExecuteNV\n"; } + device_dispatch_table(commandBuffer)->CmdOpticalFlowExecuteNV(commandBuffer, session, pExecuteInfo); } template VKAPI_ATTR void VKAPI_CALL vkAntiLagUpdateAMD(VkDevice device, const VkAntiLagDataAMD* pData) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkAntiLagUpdateAMD", "device, pData", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkAntiLagUpdateAMD(ApiDumpInstance::current(), device, pData); - } - } - device_dispatch_table(device)->AntiLagUpdateAMD(device, pData); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkAntiLagUpdateAMD(ApiDumpInstance::current(), device, pData); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkAntiLagUpdateAMD\n"; } + device_dispatch_table(device)->AntiLagUpdateAMD(device, pData); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateShadersEXT(VkDevice device, uint32_t createInfoCount, const VkShaderCreateInfoEXT* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkShaderEXT* pShaders) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateShadersEXT", "device, createInfoCount, pCreateInfos, pAllocator, pShaders", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateShadersEXT(ApiDumpInstance::current(), device, createInfoCount, pCreateInfos, pAllocator, pShaders); - } - } - VkResult result = device_dispatch_table(device)->CreateShadersEXT(device, createInfoCount, pCreateInfos, pAllocator, pShaders); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateShadersEXT(ApiDumpInstance::current(), device, createInfoCount, pCreateInfos, pAllocator, pShaders); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateShadersEXT\n"; } + VkResult result = device_dispatch_table(device)->CreateShadersEXT(device, createInfoCount, pCreateInfos, pAllocator, pShaders); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyShaderEXT(VkDevice device, VkShaderEXT shader, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyShaderEXT", "device, shader, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyShaderEXT(ApiDumpInstance::current(), device, shader, pAllocator); - } - } - device_dispatch_table(device)->DestroyShaderEXT(device, shader, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyShaderEXT(ApiDumpInstance::current(), device, shader, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyShaderEXT\n"; } + device_dispatch_table(device)->DestroyShaderEXT(device, shader, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetShaderBinaryDataEXT(VkDevice device, VkShaderEXT shader, size_t* pDataSize, void* pData) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetShaderBinaryDataEXT", "device, shader, pDataSize, pData", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetShaderBinaryDataEXT(ApiDumpInstance::current(), device, shader, pDataSize, pData); - } - } - VkResult result = device_dispatch_table(device)->GetShaderBinaryDataEXT(device, shader, pDataSize, pData); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetShaderBinaryDataEXT(ApiDumpInstance::current(), device, shader, pDataSize, pData); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetShaderBinaryDataEXT\n"; } + VkResult result = device_dispatch_table(device)->GetShaderBinaryDataEXT(device, shader, pDataSize, pData); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdBindShadersEXT(VkCommandBuffer commandBuffer, uint32_t stageCount, const VkShaderStageFlagBits* pStages, const VkShaderEXT* pShaders) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBindShadersEXT", "commandBuffer, stageCount, pStages, pShaders", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBindShadersEXT(ApiDumpInstance::current(), commandBuffer, stageCount, pStages, pShaders); - } - } - device_dispatch_table(commandBuffer)->CmdBindShadersEXT(commandBuffer, stageCount, pStages, pShaders); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBindShadersEXT(ApiDumpInstance::current(), commandBuffer, stageCount, pStages, pShaders); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBindShadersEXT\n"; } + device_dispatch_table(commandBuffer)->CmdBindShadersEXT(commandBuffer, stageCount, pStages, pShaders); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClampRangeEXT(VkCommandBuffer commandBuffer, VkDepthClampModeEXT depthClampMode, const VkDepthClampRangeEXT* pDepthClampRange) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetDepthClampRangeEXT", "commandBuffer, depthClampMode, pDepthClampRange", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDepthClampRangeEXT(ApiDumpInstance::current(), commandBuffer, depthClampMode, pDepthClampRange); - } - } - device_dispatch_table(commandBuffer)->CmdSetDepthClampRangeEXT(commandBuffer, depthClampMode, pDepthClampRange); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetDepthClampRangeEXT(ApiDumpInstance::current(), commandBuffer, depthClampMode, pDepthClampRange); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetDepthClampRangeEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetDepthClampRangeEXT(commandBuffer, depthClampMode, pDepthClampRange); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetFramebufferTilePropertiesQCOM(VkDevice device, VkFramebuffer framebuffer, uint32_t* pPropertiesCount, VkTilePropertiesQCOM* pProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetFramebufferTilePropertiesQCOM", "device, framebuffer, pPropertiesCount, pProperties", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetFramebufferTilePropertiesQCOM(ApiDumpInstance::current(), device, framebuffer, pPropertiesCount, pProperties); - } - } - VkResult result = device_dispatch_table(device)->GetFramebufferTilePropertiesQCOM(device, framebuffer, pPropertiesCount, pProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetFramebufferTilePropertiesQCOM(ApiDumpInstance::current(), device, framebuffer, pPropertiesCount, pProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetFramebufferTilePropertiesQCOM\n"; } + VkResult result = device_dispatch_table(device)->GetFramebufferTilePropertiesQCOM(device, framebuffer, pPropertiesCount, pProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDynamicRenderingTilePropertiesQCOM", "device, pRenderingInfo, pProperties", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDynamicRenderingTilePropertiesQCOM(ApiDumpInstance::current(), device, pRenderingInfo, pProperties); - } - } - VkResult result = device_dispatch_table(device)->GetDynamicRenderingTilePropertiesQCOM(device, pRenderingInfo, pProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDynamicRenderingTilePropertiesQCOM(ApiDumpInstance::current(), device, pRenderingInfo, pProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDynamicRenderingTilePropertiesQCOM\n"; } + VkResult result = device_dispatch_table(device)->GetDynamicRenderingTilePropertiesQCOM(device, pRenderingInfo, pProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkConvertCooperativeVectorMatrixNV(VkDevice device, const VkConvertCooperativeVectorMatrixInfoNV* pInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkConvertCooperativeVectorMatrixNV", "device, pInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkConvertCooperativeVectorMatrixNV(ApiDumpInstance::current(), device, pInfo); - } - } - VkResult result = device_dispatch_table(device)->ConvertCooperativeVectorMatrixNV(device, pInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkConvertCooperativeVectorMatrixNV(ApiDumpInstance::current(), device, pInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkConvertCooperativeVectorMatrixNV\n"; } + VkResult result = device_dispatch_table(device)->ConvertCooperativeVectorMatrixNV(device, pInfo); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdConvertCooperativeVectorMatrixNV(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkConvertCooperativeVectorMatrixInfoNV* pInfos) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdConvertCooperativeVectorMatrixNV", "commandBuffer, infoCount, pInfos", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdConvertCooperativeVectorMatrixNV(ApiDumpInstance::current(), commandBuffer, infoCount, pInfos); - } - } - device_dispatch_table(commandBuffer)->CmdConvertCooperativeVectorMatrixNV(commandBuffer, infoCount, pInfos); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdConvertCooperativeVectorMatrixNV(ApiDumpInstance::current(), commandBuffer, infoCount, pInfos); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdConvertCooperativeVectorMatrixNV\n"; } + device_dispatch_table(commandBuffer)->CmdConvertCooperativeVectorMatrixNV(commandBuffer, infoCount, pInfos); } template VKAPI_ATTR VkResult VKAPI_CALL vkSetLatencySleepModeNV(VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepModeInfoNV* pSleepModeInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkSetLatencySleepModeNV", "device, swapchain, pSleepModeInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkSetLatencySleepModeNV(ApiDumpInstance::current(), device, swapchain, pSleepModeInfo); - } - } - VkResult result = device_dispatch_table(device)->SetLatencySleepModeNV(device, swapchain, pSleepModeInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkSetLatencySleepModeNV(ApiDumpInstance::current(), device, swapchain, pSleepModeInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkSetLatencySleepModeNV\n"; } + VkResult result = device_dispatch_table(device)->SetLatencySleepModeNV(device, swapchain, pSleepModeInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkLatencySleepNV(VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepInfoNV* pSleepInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkLatencySleepNV", "device, swapchain, pSleepInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkLatencySleepNV(ApiDumpInstance::current(), device, swapchain, pSleepInfo); - } - } - VkResult result = device_dispatch_table(device)->LatencySleepNV(device, swapchain, pSleepInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkLatencySleepNV(ApiDumpInstance::current(), device, swapchain, pSleepInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkLatencySleepNV\n"; } + VkResult result = device_dispatch_table(device)->LatencySleepNV(device, swapchain, pSleepInfo); return result; } template VKAPI_ATTR void VKAPI_CALL vkSetLatencyMarkerNV(VkDevice device, VkSwapchainKHR swapchain, const VkSetLatencyMarkerInfoNV* pLatencyMarkerInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkSetLatencyMarkerNV", "device, swapchain, pLatencyMarkerInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkSetLatencyMarkerNV(ApiDumpInstance::current(), device, swapchain, pLatencyMarkerInfo); - } - } - device_dispatch_table(device)->SetLatencyMarkerNV(device, swapchain, pLatencyMarkerInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkSetLatencyMarkerNV(ApiDumpInstance::current(), device, swapchain, pLatencyMarkerInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkSetLatencyMarkerNV\n"; } + device_dispatch_table(device)->SetLatencyMarkerNV(device, swapchain, pLatencyMarkerInfo); } template VKAPI_ATTR void VKAPI_CALL vkGetLatencyTimingsNV(VkDevice device, VkSwapchainKHR swapchain, VkGetLatencyMarkerInfoNV* pLatencyMarkerInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetLatencyTimingsNV", "device, swapchain, pLatencyMarkerInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetLatencyTimingsNV(ApiDumpInstance::current(), device, swapchain, pLatencyMarkerInfo); - } - } - device_dispatch_table(device)->GetLatencyTimingsNV(device, swapchain, pLatencyMarkerInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetLatencyTimingsNV(ApiDumpInstance::current(), device, swapchain, pLatencyMarkerInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetLatencyTimingsNV\n"; } + device_dispatch_table(device)->GetLatencyTimingsNV(device, swapchain, pLatencyMarkerInfo); } template VKAPI_ATTR void VKAPI_CALL vkQueueNotifyOutOfBandNV(VkQueue queue, const VkOutOfBandQueueTypeInfoNV* pQueueTypeInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkQueueNotifyOutOfBandNV", "queue, pQueueTypeInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkQueueNotifyOutOfBandNV(ApiDumpInstance::current(), queue, pQueueTypeInfo); - } - } - device_dispatch_table(queue)->QueueNotifyOutOfBandNV(queue, pQueueTypeInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkQueueNotifyOutOfBandNV(ApiDumpInstance::current(), queue, pQueueTypeInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkQueueNotifyOutOfBandNV\n"; } + device_dispatch_table(queue)->QueueNotifyOutOfBandNV(queue, pQueueTypeInfo); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateDataGraphPipelinesARM(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkDataGraphPipelineCreateInfoARM* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateDataGraphPipelinesARM", "device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateDataGraphPipelinesARM(ApiDumpInstance::current(), device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); - } - } - VkResult result = device_dispatch_table(device)->CreateDataGraphPipelinesARM(device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateDataGraphPipelinesARM(ApiDumpInstance::current(), device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateDataGraphPipelinesARM\n"; } + VkResult result = device_dispatch_table(device)->CreateDataGraphPipelinesARM(device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateDataGraphPipelineSessionARM(VkDevice device, const VkDataGraphPipelineSessionCreateInfoARM* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDataGraphPipelineSessionARM* pSession) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateDataGraphPipelineSessionARM", "device, pCreateInfo, pAllocator, pSession", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateDataGraphPipelineSessionARM(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pSession); - } - } - VkResult result = device_dispatch_table(device)->CreateDataGraphPipelineSessionARM(device, pCreateInfo, pAllocator, pSession); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateDataGraphPipelineSessionARM(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pSession); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateDataGraphPipelineSessionARM\n"; } + VkResult result = device_dispatch_table(device)->CreateDataGraphPipelineSessionARM(device, pCreateInfo, pAllocator, pSession); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetDataGraphPipelineSessionBindPointRequirementsARM(VkDevice device, const VkDataGraphPipelineSessionBindPointRequirementsInfoARM* pInfo, uint32_t* pBindPointRequirementCount, VkDataGraphPipelineSessionBindPointRequirementARM* pBindPointRequirements) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDataGraphPipelineSessionBindPointRequirementsARM", "device, pInfo, pBindPointRequirementCount, pBindPointRequirements", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDataGraphPipelineSessionBindPointRequirementsARM(ApiDumpInstance::current(), device, pInfo, pBindPointRequirementCount, pBindPointRequirements); - } - } - VkResult result = device_dispatch_table(device)->GetDataGraphPipelineSessionBindPointRequirementsARM(device, pInfo, pBindPointRequirementCount, pBindPointRequirements); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDataGraphPipelineSessionBindPointRequirementsARM(ApiDumpInstance::current(), device, pInfo, pBindPointRequirementCount, pBindPointRequirements); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDataGraphPipelineSessionBindPointRequirementsARM\n"; } + VkResult result = device_dispatch_table(device)->GetDataGraphPipelineSessionBindPointRequirementsARM(device, pInfo, pBindPointRequirementCount, pBindPointRequirements); return result; } template VKAPI_ATTR void VKAPI_CALL vkGetDataGraphPipelineSessionMemoryRequirementsARM(VkDevice device, const VkDataGraphPipelineSessionMemoryRequirementsInfoARM* pInfo, VkMemoryRequirements2* pMemoryRequirements) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDataGraphPipelineSessionMemoryRequirementsARM", "device, pInfo, pMemoryRequirements", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDataGraphPipelineSessionMemoryRequirementsARM(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements); - } - } - device_dispatch_table(device)->GetDataGraphPipelineSessionMemoryRequirementsARM(device, pInfo, pMemoryRequirements); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDataGraphPipelineSessionMemoryRequirementsARM(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDataGraphPipelineSessionMemoryRequirementsARM\n"; } + device_dispatch_table(device)->GetDataGraphPipelineSessionMemoryRequirementsARM(device, pInfo, pMemoryRequirements); } template VKAPI_ATTR VkResult VKAPI_CALL vkBindDataGraphPipelineSessionMemoryARM(VkDevice device, uint32_t bindInfoCount, const VkBindDataGraphPipelineSessionMemoryInfoARM* pBindInfos) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkBindDataGraphPipelineSessionMemoryARM", "device, bindInfoCount, pBindInfos", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkBindDataGraphPipelineSessionMemoryARM(ApiDumpInstance::current(), device, bindInfoCount, pBindInfos); - } - } - VkResult result = device_dispatch_table(device)->BindDataGraphPipelineSessionMemoryARM(device, bindInfoCount, pBindInfos); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkBindDataGraphPipelineSessionMemoryARM(ApiDumpInstance::current(), device, bindInfoCount, pBindInfos); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkBindDataGraphPipelineSessionMemoryARM\n"; } + VkResult result = device_dispatch_table(device)->BindDataGraphPipelineSessionMemoryARM(device, bindInfoCount, pBindInfos); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyDataGraphPipelineSessionARM(VkDevice device, VkDataGraphPipelineSessionARM session, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyDataGraphPipelineSessionARM", "device, session, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyDataGraphPipelineSessionARM(ApiDumpInstance::current(), device, session, pAllocator); - } - } - device_dispatch_table(device)->DestroyDataGraphPipelineSessionARM(device, session, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyDataGraphPipelineSessionARM(ApiDumpInstance::current(), device, session, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyDataGraphPipelineSessionARM\n"; } + device_dispatch_table(device)->DestroyDataGraphPipelineSessionARM(device, session, pAllocator); } template VKAPI_ATTR void VKAPI_CALL vkCmdDispatchDataGraphARM(VkCommandBuffer commandBuffer, VkDataGraphPipelineSessionARM session, const VkDataGraphPipelineDispatchInfoARM* pInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdDispatchDataGraphARM", "commandBuffer, session, pInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDispatchDataGraphARM(ApiDumpInstance::current(), commandBuffer, session, pInfo); - } - } - device_dispatch_table(commandBuffer)->CmdDispatchDataGraphARM(commandBuffer, session, pInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDispatchDataGraphARM(ApiDumpInstance::current(), commandBuffer, session, pInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdDispatchDataGraphARM\n"; } + device_dispatch_table(commandBuffer)->CmdDispatchDataGraphARM(commandBuffer, session, pInfo); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetDataGraphPipelineAvailablePropertiesARM(VkDevice device, const VkDataGraphPipelineInfoARM* pPipelineInfo, uint32_t* pPropertiesCount, VkDataGraphPipelinePropertyARM* pProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDataGraphPipelineAvailablePropertiesARM", "device, pPipelineInfo, pPropertiesCount, pProperties", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDataGraphPipelineAvailablePropertiesARM(ApiDumpInstance::current(), device, pPipelineInfo, pPropertiesCount, pProperties); - } - } - VkResult result = device_dispatch_table(device)->GetDataGraphPipelineAvailablePropertiesARM(device, pPipelineInfo, pPropertiesCount, pProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDataGraphPipelineAvailablePropertiesARM(ApiDumpInstance::current(), device, pPipelineInfo, pPropertiesCount, pProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDataGraphPipelineAvailablePropertiesARM\n"; } + VkResult result = device_dispatch_table(device)->GetDataGraphPipelineAvailablePropertiesARM(device, pPipelineInfo, pPropertiesCount, pProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetDataGraphPipelinePropertiesARM(VkDevice device, const VkDataGraphPipelineInfoARM* pPipelineInfo, uint32_t propertiesCount, VkDataGraphPipelinePropertyQueryResultARM* pProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDataGraphPipelinePropertiesARM", "device, pPipelineInfo, propertiesCount, pProperties", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDataGraphPipelinePropertiesARM(ApiDumpInstance::current(), device, pPipelineInfo, propertiesCount, pProperties); - } - } - VkResult result = device_dispatch_table(device)->GetDataGraphPipelinePropertiesARM(device, pPipelineInfo, propertiesCount, pProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDataGraphPipelinePropertiesARM(ApiDumpInstance::current(), device, pPipelineInfo, propertiesCount, pProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDataGraphPipelinePropertiesARM\n"; } + VkResult result = device_dispatch_table(device)->GetDataGraphPipelinePropertiesARM(device, pPipelineInfo, propertiesCount, pProperties); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdSetAttachmentFeedbackLoopEnableEXT(VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetAttachmentFeedbackLoopEnableEXT", "commandBuffer, aspectMask", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetAttachmentFeedbackLoopEnableEXT(ApiDumpInstance::current(), commandBuffer, aspectMask); - } - } - device_dispatch_table(commandBuffer)->CmdSetAttachmentFeedbackLoopEnableEXT(commandBuffer, aspectMask); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetAttachmentFeedbackLoopEnableEXT(ApiDumpInstance::current(), commandBuffer, aspectMask); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetAttachmentFeedbackLoopEnableEXT\n"; } + device_dispatch_table(commandBuffer)->CmdSetAttachmentFeedbackLoopEnableEXT(commandBuffer, aspectMask); } #if defined(VK_USE_PLATFORM_SCREEN_QNX) template VKAPI_ATTR VkResult VKAPI_CALL vkGetScreenBufferPropertiesQNX(VkDevice device, const struct _screen_buffer* buffer, VkScreenBufferPropertiesQNX* pProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetScreenBufferPropertiesQNX", "device, buffer, pProperties", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetScreenBufferPropertiesQNX(ApiDumpInstance::current(), device, buffer, pProperties); - } - } - VkResult result = device_dispatch_table(device)->GetScreenBufferPropertiesQNX(device, buffer, pProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetScreenBufferPropertiesQNX(ApiDumpInstance::current(), device, buffer, pProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetScreenBufferPropertiesQNX\n"; } + VkResult result = device_dispatch_table(device)->GetScreenBufferPropertiesQNX(device, buffer, pProperties); return result; } #endif // VK_USE_PLATFORM_SCREEN_QNX @@ -14386,410 +6861,195 @@ template VKAPI_ATTR void VKAPI_CALL vkCmdBindTileMemoryQCOM(VkCommandBuffer commandBuffer, const VkTileMemoryBindInfoQCOM* pTileMemoryBindInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBindTileMemoryQCOM", "commandBuffer, pTileMemoryBindInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBindTileMemoryQCOM(ApiDumpInstance::current(), commandBuffer, pTileMemoryBindInfo); - } - } - device_dispatch_table(commandBuffer)->CmdBindTileMemoryQCOM(commandBuffer, pTileMemoryBindInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBindTileMemoryQCOM(ApiDumpInstance::current(), commandBuffer, pTileMemoryBindInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBindTileMemoryQCOM\n"; } + device_dispatch_table(commandBuffer)->CmdBindTileMemoryQCOM(commandBuffer, pTileMemoryBindInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdDecompressMemoryEXT(VkCommandBuffer commandBuffer, const VkDecompressMemoryInfoEXT* pDecompressMemoryInfoEXT) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdDecompressMemoryEXT", "commandBuffer, pDecompressMemoryInfoEXT", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDecompressMemoryEXT(ApiDumpInstance::current(), commandBuffer, pDecompressMemoryInfoEXT); - } - } - device_dispatch_table(commandBuffer)->CmdDecompressMemoryEXT(commandBuffer, pDecompressMemoryInfoEXT); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDecompressMemoryEXT(ApiDumpInstance::current(), commandBuffer, pDecompressMemoryInfoEXT); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdDecompressMemoryEXT\n"; } + device_dispatch_table(commandBuffer)->CmdDecompressMemoryEXT(commandBuffer, pDecompressMemoryInfoEXT); } template VKAPI_ATTR void VKAPI_CALL vkCmdDecompressMemoryIndirectCountEXT(VkCommandBuffer commandBuffer, VkMemoryDecompressionMethodFlagsEXT decompressionMethod, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t maxDecompressionCount, uint32_t stride) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdDecompressMemoryIndirectCountEXT", "commandBuffer, decompressionMethod, indirectCommandsAddress, indirectCommandsCountAddress, maxDecompressionCount, stride", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDecompressMemoryIndirectCountEXT(ApiDumpInstance::current(), commandBuffer, decompressionMethod, indirectCommandsAddress, indirectCommandsCountAddress, maxDecompressionCount, stride); - } - } - device_dispatch_table(commandBuffer)->CmdDecompressMemoryIndirectCountEXT(commandBuffer, decompressionMethod, indirectCommandsAddress, indirectCommandsCountAddress, maxDecompressionCount, stride); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDecompressMemoryIndirectCountEXT(ApiDumpInstance::current(), commandBuffer, decompressionMethod, indirectCommandsAddress, indirectCommandsCountAddress, maxDecompressionCount, stride); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdDecompressMemoryIndirectCountEXT\n"; } + device_dispatch_table(commandBuffer)->CmdDecompressMemoryIndirectCountEXT(commandBuffer, decompressionMethod, indirectCommandsAddress, indirectCommandsCountAddress, maxDecompressionCount, stride); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateExternalComputeQueueNV(VkDevice device, const VkExternalComputeQueueCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkExternalComputeQueueNV* pExternalQueue) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateExternalComputeQueueNV", "device, pCreateInfo, pAllocator, pExternalQueue", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateExternalComputeQueueNV(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pExternalQueue); - } - } - VkResult result = device_dispatch_table(device)->CreateExternalComputeQueueNV(device, pCreateInfo, pAllocator, pExternalQueue); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateExternalComputeQueueNV(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pExternalQueue); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateExternalComputeQueueNV\n"; } + VkResult result = device_dispatch_table(device)->CreateExternalComputeQueueNV(device, pCreateInfo, pAllocator, pExternalQueue); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyExternalComputeQueueNV(VkDevice device, VkExternalComputeQueueNV externalQueue, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyExternalComputeQueueNV", "device, externalQueue, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyExternalComputeQueueNV(ApiDumpInstance::current(), device, externalQueue, pAllocator); - } - } - device_dispatch_table(device)->DestroyExternalComputeQueueNV(device, externalQueue, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyExternalComputeQueueNV(ApiDumpInstance::current(), device, externalQueue, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyExternalComputeQueueNV\n"; } + device_dispatch_table(device)->DestroyExternalComputeQueueNV(device, externalQueue, pAllocator); } template VKAPI_ATTR void VKAPI_CALL vkGetExternalComputeQueueDataNV(VkExternalComputeQueueNV externalQueue, VkExternalComputeQueueDataParamsNV* params, void* pData) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetExternalComputeQueueDataNV", "externalQueue, params, pData", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetExternalComputeQueueDataNV(ApiDumpInstance::current(), externalQueue, params, pData); - } - } - device_dispatch_table(externalQueue)->GetExternalComputeQueueDataNV(externalQueue, params, pData); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetExternalComputeQueueDataNV(ApiDumpInstance::current(), externalQueue, params, pData); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetExternalComputeQueueDataNV\n"; } + device_dispatch_table(externalQueue)->GetExternalComputeQueueDataNV(externalQueue, params, pData); } template VKAPI_ATTR void VKAPI_CALL vkGetClusterAccelerationStructureBuildSizesNV(VkDevice device, const VkClusterAccelerationStructureInputInfoNV* pInfo, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetClusterAccelerationStructureBuildSizesNV", "device, pInfo, pSizeInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetClusterAccelerationStructureBuildSizesNV(ApiDumpInstance::current(), device, pInfo, pSizeInfo); - } - } - device_dispatch_table(device)->GetClusterAccelerationStructureBuildSizesNV(device, pInfo, pSizeInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetClusterAccelerationStructureBuildSizesNV(ApiDumpInstance::current(), device, pInfo, pSizeInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetClusterAccelerationStructureBuildSizesNV\n"; } + device_dispatch_table(device)->GetClusterAccelerationStructureBuildSizesNV(device, pInfo, pSizeInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdBuildClusterAccelerationStructureIndirectNV(VkCommandBuffer commandBuffer, const VkClusterAccelerationStructureCommandsInfoNV* pCommandInfos) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBuildClusterAccelerationStructureIndirectNV", "commandBuffer, pCommandInfos", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBuildClusterAccelerationStructureIndirectNV(ApiDumpInstance::current(), commandBuffer, pCommandInfos); - } - } - device_dispatch_table(commandBuffer)->CmdBuildClusterAccelerationStructureIndirectNV(commandBuffer, pCommandInfos); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBuildClusterAccelerationStructureIndirectNV(ApiDumpInstance::current(), commandBuffer, pCommandInfos); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBuildClusterAccelerationStructureIndirectNV\n"; } + device_dispatch_table(commandBuffer)->CmdBuildClusterAccelerationStructureIndirectNV(commandBuffer, pCommandInfos); } template VKAPI_ATTR void VKAPI_CALL vkGetPartitionedAccelerationStructuresBuildSizesNV(VkDevice device, const VkPartitionedAccelerationStructureInstancesInputNV* pInfo, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetPartitionedAccelerationStructuresBuildSizesNV", "device, pInfo, pSizeInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPartitionedAccelerationStructuresBuildSizesNV(ApiDumpInstance::current(), device, pInfo, pSizeInfo); - } - } - device_dispatch_table(device)->GetPartitionedAccelerationStructuresBuildSizesNV(device, pInfo, pSizeInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetPartitionedAccelerationStructuresBuildSizesNV(ApiDumpInstance::current(), device, pInfo, pSizeInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetPartitionedAccelerationStructuresBuildSizesNV\n"; } + device_dispatch_table(device)->GetPartitionedAccelerationStructuresBuildSizesNV(device, pInfo, pSizeInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdBuildPartitionedAccelerationStructuresNV(VkCommandBuffer commandBuffer, const VkBuildPartitionedAccelerationStructureInfoNV* pBuildInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBuildPartitionedAccelerationStructuresNV", "commandBuffer, pBuildInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBuildPartitionedAccelerationStructuresNV(ApiDumpInstance::current(), commandBuffer, pBuildInfo); - } - } - device_dispatch_table(commandBuffer)->CmdBuildPartitionedAccelerationStructuresNV(commandBuffer, pBuildInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBuildPartitionedAccelerationStructuresNV(ApiDumpInstance::current(), commandBuffer, pBuildInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBuildPartitionedAccelerationStructuresNV\n"; } + device_dispatch_table(commandBuffer)->CmdBuildPartitionedAccelerationStructuresNV(commandBuffer, pBuildInfo); } template VKAPI_ATTR void VKAPI_CALL vkGetGeneratedCommandsMemoryRequirementsEXT(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoEXT* pInfo, VkMemoryRequirements2* pMemoryRequirements) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetGeneratedCommandsMemoryRequirementsEXT", "device, pInfo, pMemoryRequirements", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetGeneratedCommandsMemoryRequirementsEXT(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements); - } - } - device_dispatch_table(device)->GetGeneratedCommandsMemoryRequirementsEXT(device, pInfo, pMemoryRequirements); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetGeneratedCommandsMemoryRequirementsEXT(ApiDumpInstance::current(), device, pInfo, pMemoryRequirements); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetGeneratedCommandsMemoryRequirementsEXT\n"; } + device_dispatch_table(device)->GetGeneratedCommandsMemoryRequirementsEXT(device, pInfo, pMemoryRequirements); } template VKAPI_ATTR void VKAPI_CALL vkCmdPreprocessGeneratedCommandsEXT(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo, VkCommandBuffer stateCommandBuffer) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdPreprocessGeneratedCommandsEXT", "commandBuffer, pGeneratedCommandsInfo, stateCommandBuffer", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdPreprocessGeneratedCommandsEXT(ApiDumpInstance::current(), commandBuffer, pGeneratedCommandsInfo, stateCommandBuffer); - } - } - device_dispatch_table(commandBuffer)->CmdPreprocessGeneratedCommandsEXT(commandBuffer, pGeneratedCommandsInfo, stateCommandBuffer); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdPreprocessGeneratedCommandsEXT(ApiDumpInstance::current(), commandBuffer, pGeneratedCommandsInfo, stateCommandBuffer); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdPreprocessGeneratedCommandsEXT\n"; } + device_dispatch_table(commandBuffer)->CmdPreprocessGeneratedCommandsEXT(commandBuffer, pGeneratedCommandsInfo, stateCommandBuffer); } template VKAPI_ATTR void VKAPI_CALL vkCmdExecuteGeneratedCommandsEXT(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdExecuteGeneratedCommandsEXT", "commandBuffer, isPreprocessed, pGeneratedCommandsInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdExecuteGeneratedCommandsEXT(ApiDumpInstance::current(), commandBuffer, isPreprocessed, pGeneratedCommandsInfo); - } - } - device_dispatch_table(commandBuffer)->CmdExecuteGeneratedCommandsEXT(commandBuffer, isPreprocessed, pGeneratedCommandsInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdExecuteGeneratedCommandsEXT(ApiDumpInstance::current(), commandBuffer, isPreprocessed, pGeneratedCommandsInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdExecuteGeneratedCommandsEXT\n"; } + device_dispatch_table(commandBuffer)->CmdExecuteGeneratedCommandsEXT(commandBuffer, isPreprocessed, pGeneratedCommandsInfo); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutEXT(VkDevice device, const VkIndirectCommandsLayoutCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutEXT* pIndirectCommandsLayout) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateIndirectCommandsLayoutEXT", "device, pCreateInfo, pAllocator, pIndirectCommandsLayout", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateIndirectCommandsLayoutEXT(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pIndirectCommandsLayout); - } - } - VkResult result = device_dispatch_table(device)->CreateIndirectCommandsLayoutEXT(device, pCreateInfo, pAllocator, pIndirectCommandsLayout); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateIndirectCommandsLayoutEXT(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pIndirectCommandsLayout); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateIndirectCommandsLayoutEXT\n"; } + VkResult result = device_dispatch_table(device)->CreateIndirectCommandsLayoutEXT(device, pCreateInfo, pAllocator, pIndirectCommandsLayout); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutEXT(VkDevice device, VkIndirectCommandsLayoutEXT indirectCommandsLayout, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyIndirectCommandsLayoutEXT", "device, indirectCommandsLayout, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyIndirectCommandsLayoutEXT(ApiDumpInstance::current(), device, indirectCommandsLayout, pAllocator); - } - } - device_dispatch_table(device)->DestroyIndirectCommandsLayoutEXT(device, indirectCommandsLayout, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyIndirectCommandsLayoutEXT(ApiDumpInstance::current(), device, indirectCommandsLayout, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyIndirectCommandsLayoutEXT\n"; } + device_dispatch_table(device)->DestroyIndirectCommandsLayoutEXT(device, indirectCommandsLayout, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectExecutionSetEXT(VkDevice device, const VkIndirectExecutionSetCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectExecutionSetEXT* pIndirectExecutionSet) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateIndirectExecutionSetEXT", "device, pCreateInfo, pAllocator, pIndirectExecutionSet", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateIndirectExecutionSetEXT(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pIndirectExecutionSet); - } - } - VkResult result = device_dispatch_table(device)->CreateIndirectExecutionSetEXT(device, pCreateInfo, pAllocator, pIndirectExecutionSet); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateIndirectExecutionSetEXT(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pIndirectExecutionSet); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateIndirectExecutionSetEXT\n"; } + VkResult result = device_dispatch_table(device)->CreateIndirectExecutionSetEXT(device, pCreateInfo, pAllocator, pIndirectExecutionSet); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectExecutionSetEXT(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyIndirectExecutionSetEXT", "device, indirectExecutionSet, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyIndirectExecutionSetEXT(ApiDumpInstance::current(), device, indirectExecutionSet, pAllocator); - } - } - device_dispatch_table(device)->DestroyIndirectExecutionSetEXT(device, indirectExecutionSet, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyIndirectExecutionSetEXT(ApiDumpInstance::current(), device, indirectExecutionSet, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyIndirectExecutionSetEXT\n"; } + device_dispatch_table(device)->DestroyIndirectExecutionSetEXT(device, indirectExecutionSet, pAllocator); } template VKAPI_ATTR void VKAPI_CALL vkUpdateIndirectExecutionSetPipelineEXT(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, const VkWriteIndirectExecutionSetPipelineEXT* pExecutionSetWrites) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkUpdateIndirectExecutionSetPipelineEXT", "device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkUpdateIndirectExecutionSetPipelineEXT(ApiDumpInstance::current(), device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites); - } - } - device_dispatch_table(device)->UpdateIndirectExecutionSetPipelineEXT(device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkUpdateIndirectExecutionSetPipelineEXT(ApiDumpInstance::current(), device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkUpdateIndirectExecutionSetPipelineEXT\n"; } + device_dispatch_table(device)->UpdateIndirectExecutionSetPipelineEXT(device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites); } template VKAPI_ATTR void VKAPI_CALL vkUpdateIndirectExecutionSetShaderEXT(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, const VkWriteIndirectExecutionSetShaderEXT* pExecutionSetWrites) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkUpdateIndirectExecutionSetShaderEXT", "device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkUpdateIndirectExecutionSetShaderEXT(ApiDumpInstance::current(), device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites); - } - } - device_dispatch_table(device)->UpdateIndirectExecutionSetShaderEXT(device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkUpdateIndirectExecutionSetShaderEXT(ApiDumpInstance::current(), device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkUpdateIndirectExecutionSetShaderEXT\n"; } + device_dispatch_table(device)->UpdateIndirectExecutionSetShaderEXT(device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites); } #if defined(VK_USE_PLATFORM_METAL_EXT) template VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryMetalHandleEXT(VkDevice device, const VkMemoryGetMetalHandleInfoEXT* pGetMetalHandleInfo, void** pHandle) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetMemoryMetalHandleEXT", "device, pGetMetalHandleInfo, pHandle", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetMemoryMetalHandleEXT(ApiDumpInstance::current(), device, pGetMetalHandleInfo, pHandle); - } - } - VkResult result = device_dispatch_table(device)->GetMemoryMetalHandleEXT(device, pGetMetalHandleInfo, pHandle); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetMemoryMetalHandleEXT(ApiDumpInstance::current(), device, pGetMetalHandleInfo, pHandle); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetMemoryMetalHandleEXT\n"; } + VkResult result = device_dispatch_table(device)->GetMemoryMetalHandleEXT(device, pGetMetalHandleInfo, pHandle); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryMetalHandlePropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHandle, VkMemoryMetalHandlePropertiesEXT* pMemoryMetalHandleProperties) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetMemoryMetalHandlePropertiesEXT", "device, handleType, pHandle, pMemoryMetalHandleProperties", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetMemoryMetalHandlePropertiesEXT(ApiDumpInstance::current(), device, handleType, pHandle, pMemoryMetalHandleProperties); - } - } - VkResult result = device_dispatch_table(device)->GetMemoryMetalHandlePropertiesEXT(device, handleType, pHandle, pMemoryMetalHandleProperties); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetMemoryMetalHandlePropertiesEXT(ApiDumpInstance::current(), device, handleType, pHandle, pMemoryMetalHandleProperties); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetMemoryMetalHandlePropertiesEXT\n"; } + VkResult result = device_dispatch_table(device)->GetMemoryMetalHandlePropertiesEXT(device, handleType, pHandle, pMemoryMetalHandleProperties); return result; } #endif // VK_USE_PLATFORM_METAL_EXT @@ -14797,553 +7057,263 @@ template VKAPI_ATTR void VKAPI_CALL vkCmdEndRendering2EXT(VkCommandBuffer commandBuffer, const VkRenderingEndInfoKHR* pRenderingEndInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdEndRendering2EXT", "commandBuffer, pRenderingEndInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdEndRendering2EXT(ApiDumpInstance::current(), commandBuffer, pRenderingEndInfo); - } - } - device_dispatch_table(commandBuffer)->CmdEndRendering2EXT(commandBuffer, pRenderingEndInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdEndRendering2EXT(ApiDumpInstance::current(), commandBuffer, pRenderingEndInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdEndRendering2EXT\n"; } + device_dispatch_table(commandBuffer)->CmdEndRendering2EXT(commandBuffer, pRenderingEndInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdBeginCustomResolveEXT(VkCommandBuffer commandBuffer, const VkBeginCustomResolveInfoEXT* pBeginCustomResolveInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBeginCustomResolveEXT", "commandBuffer, pBeginCustomResolveInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBeginCustomResolveEXT(ApiDumpInstance::current(), commandBuffer, pBeginCustomResolveInfo); - } - } - device_dispatch_table(commandBuffer)->CmdBeginCustomResolveEXT(commandBuffer, pBeginCustomResolveInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBeginCustomResolveEXT(ApiDumpInstance::current(), commandBuffer, pBeginCustomResolveInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBeginCustomResolveEXT\n"; } + device_dispatch_table(commandBuffer)->CmdBeginCustomResolveEXT(commandBuffer, pBeginCustomResolveInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetComputeOccupancyPriorityNV(VkCommandBuffer commandBuffer, const VkComputeOccupancyPriorityParametersNV* pParameters) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetComputeOccupancyPriorityNV", "commandBuffer, pParameters", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetComputeOccupancyPriorityNV(ApiDumpInstance::current(), commandBuffer, pParameters); - } - } - device_dispatch_table(commandBuffer)->CmdSetComputeOccupancyPriorityNV(commandBuffer, pParameters); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetComputeOccupancyPriorityNV(ApiDumpInstance::current(), commandBuffer, pParameters); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetComputeOccupancyPriorityNV\n"; } + device_dispatch_table(commandBuffer)->CmdSetComputeOccupancyPriorityNV(commandBuffer, pParameters); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateAccelerationStructureKHR", "device, pCreateInfo, pAllocator, pAccelerationStructure", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateAccelerationStructureKHR(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pAccelerationStructure); - } - } - VkResult result = device_dispatch_table(device)->CreateAccelerationStructureKHR(device, pCreateInfo, pAllocator, pAccelerationStructure); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateAccelerationStructureKHR(ApiDumpInstance::current(), device, pCreateInfo, pAllocator, pAccelerationStructure); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateAccelerationStructureKHR\n"; } + VkResult result = device_dispatch_table(device)->CreateAccelerationStructureKHR(device, pCreateInfo, pAllocator, pAccelerationStructure); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyAccelerationStructureKHR(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks* pAllocator) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkDestroyAccelerationStructureKHR", "device, accelerationStructure, pAllocator", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyAccelerationStructureKHR(ApiDumpInstance::current(), device, accelerationStructure, pAllocator); - } - } - device_dispatch_table(device)->DestroyAccelerationStructureKHR(device, accelerationStructure, pAllocator); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkDestroyAccelerationStructureKHR(ApiDumpInstance::current(), device, accelerationStructure, pAllocator); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkDestroyAccelerationStructureKHR\n"; } + device_dispatch_table(device)->DestroyAccelerationStructureKHR(device, accelerationStructure, pAllocator); } template VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructuresKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBuildAccelerationStructuresKHR", "commandBuffer, infoCount, pInfos, ppBuildRangeInfos", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBuildAccelerationStructuresKHR(ApiDumpInstance::current(), commandBuffer, infoCount, pInfos, ppBuildRangeInfos); - } - } - device_dispatch_table(commandBuffer)->CmdBuildAccelerationStructuresKHR(commandBuffer, infoCount, pInfos, ppBuildRangeInfos); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBuildAccelerationStructuresKHR(ApiDumpInstance::current(), commandBuffer, infoCount, pInfos, ppBuildRangeInfos); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBuildAccelerationStructuresKHR\n"; } + device_dispatch_table(commandBuffer)->CmdBuildAccelerationStructuresKHR(commandBuffer, infoCount, pInfos, ppBuildRangeInfos); } template VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructuresIndirectKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkDeviceAddress* pIndirectDeviceAddresses, const uint32_t* pIndirectStrides, const uint32_t* const* ppMaxPrimitiveCounts) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdBuildAccelerationStructuresIndirectKHR", "commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBuildAccelerationStructuresIndirectKHR(ApiDumpInstance::current(), commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts); - } - } - device_dispatch_table(commandBuffer)->CmdBuildAccelerationStructuresIndirectKHR(commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdBuildAccelerationStructuresIndirectKHR(ApiDumpInstance::current(), commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdBuildAccelerationStructuresIndirectKHR\n"; } + device_dispatch_table(commandBuffer)->CmdBuildAccelerationStructuresIndirectKHR(commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts); } template VKAPI_ATTR VkResult VKAPI_CALL vkBuildAccelerationStructuresKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkBuildAccelerationStructuresKHR", "device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkBuildAccelerationStructuresKHR(ApiDumpInstance::current(), device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos); - } - } - VkResult result = device_dispatch_table(device)->BuildAccelerationStructuresKHR(device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkBuildAccelerationStructuresKHR(ApiDumpInstance::current(), device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkBuildAccelerationStructuresKHR\n"; } + VkResult result = device_dispatch_table(device)->BuildAccelerationStructuresKHR(device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCopyAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR* pInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCopyAccelerationStructureKHR", "device, deferredOperation, pInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCopyAccelerationStructureKHR(ApiDumpInstance::current(), device, deferredOperation, pInfo); - } - } - VkResult result = device_dispatch_table(device)->CopyAccelerationStructureKHR(device, deferredOperation, pInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCopyAccelerationStructureKHR(ApiDumpInstance::current(), device, deferredOperation, pInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCopyAccelerationStructureKHR\n"; } + VkResult result = device_dispatch_table(device)->CopyAccelerationStructureKHR(device, deferredOperation, pInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCopyAccelerationStructureToMemoryKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCopyAccelerationStructureToMemoryKHR", "device, deferredOperation, pInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCopyAccelerationStructureToMemoryKHR(ApiDumpInstance::current(), device, deferredOperation, pInfo); - } - } - VkResult result = device_dispatch_table(device)->CopyAccelerationStructureToMemoryKHR(device, deferredOperation, pInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCopyAccelerationStructureToMemoryKHR(ApiDumpInstance::current(), device, deferredOperation, pInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCopyAccelerationStructureToMemoryKHR\n"; } + VkResult result = device_dispatch_table(device)->CopyAccelerationStructureToMemoryKHR(device, deferredOperation, pInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCopyMemoryToAccelerationStructureKHR", "device, deferredOperation, pInfo", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCopyMemoryToAccelerationStructureKHR(ApiDumpInstance::current(), device, deferredOperation, pInfo); - } - } - VkResult result = device_dispatch_table(device)->CopyMemoryToAccelerationStructureKHR(device, deferredOperation, pInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCopyMemoryToAccelerationStructureKHR(ApiDumpInstance::current(), device, deferredOperation, pInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCopyMemoryToAccelerationStructureKHR\n"; } + VkResult result = device_dispatch_table(device)->CopyMemoryToAccelerationStructureKHR(device, deferredOperation, pInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkWriteAccelerationStructuresPropertiesKHR(VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, size_t dataSize, void* pData, size_t stride) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkWriteAccelerationStructuresPropertiesKHR", "device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkWriteAccelerationStructuresPropertiesKHR(ApiDumpInstance::current(), device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride); - } - } - VkResult result = device_dispatch_table(device)->WriteAccelerationStructuresPropertiesKHR(device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkWriteAccelerationStructuresPropertiesKHR(ApiDumpInstance::current(), device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkWriteAccelerationStructuresPropertiesKHR\n"; } + VkResult result = device_dispatch_table(device)->WriteAccelerationStructuresPropertiesKHR(device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR* pInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdCopyAccelerationStructureKHR", "commandBuffer, pInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyAccelerationStructureKHR(ApiDumpInstance::current(), commandBuffer, pInfo); - } - } - device_dispatch_table(commandBuffer)->CmdCopyAccelerationStructureKHR(commandBuffer, pInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyAccelerationStructureKHR(ApiDumpInstance::current(), commandBuffer, pInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdCopyAccelerationStructureKHR\n"; } + device_dispatch_table(commandBuffer)->CmdCopyAccelerationStructureKHR(commandBuffer, pInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureToMemoryKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdCopyAccelerationStructureToMemoryKHR", "commandBuffer, pInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyAccelerationStructureToMemoryKHR(ApiDumpInstance::current(), commandBuffer, pInfo); - } - } - device_dispatch_table(commandBuffer)->CmdCopyAccelerationStructureToMemoryKHR(commandBuffer, pInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyAccelerationStructureToMemoryKHR(ApiDumpInstance::current(), commandBuffer, pInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdCopyAccelerationStructureToMemoryKHR\n"; } + device_dispatch_table(commandBuffer)->CmdCopyAccelerationStructureToMemoryKHR(commandBuffer, pInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdCopyMemoryToAccelerationStructureKHR", "commandBuffer, pInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyMemoryToAccelerationStructureKHR(ApiDumpInstance::current(), commandBuffer, pInfo); - } - } - device_dispatch_table(commandBuffer)->CmdCopyMemoryToAccelerationStructureKHR(commandBuffer, pInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdCopyMemoryToAccelerationStructureKHR(ApiDumpInstance::current(), commandBuffer, pInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdCopyMemoryToAccelerationStructureKHR\n"; } + device_dispatch_table(commandBuffer)->CmdCopyMemoryToAccelerationStructureKHR(commandBuffer, pInfo); } template VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetAccelerationStructureDeviceAddressKHR(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetAccelerationStructureDeviceAddressKHR", "device, pInfo", "VkDeviceAddress"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetAccelerationStructureDeviceAddressKHR(ApiDumpInstance::current(), device, pInfo); - } - } - VkDeviceAddress result = device_dispatch_table(device)->GetAccelerationStructureDeviceAddressKHR(device, pInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkDeviceAddress", result, dump_return_value_VkDeviceAddress); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetAccelerationStructureDeviceAddressKHR(ApiDumpInstance::current(), device, pInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetAccelerationStructureDeviceAddressKHR\n"; } + VkDeviceAddress result = device_dispatch_table(device)->GetAccelerationStructureDeviceAddressKHR(device, pInfo); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdWriteAccelerationStructuresPropertiesKHR(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdWriteAccelerationStructuresPropertiesKHR", "commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdWriteAccelerationStructuresPropertiesKHR(ApiDumpInstance::current(), commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery); - } - } - device_dispatch_table(commandBuffer)->CmdWriteAccelerationStructuresPropertiesKHR(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdWriteAccelerationStructuresPropertiesKHR(ApiDumpInstance::current(), commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdWriteAccelerationStructuresPropertiesKHR\n"; } + device_dispatch_table(commandBuffer)->CmdWriteAccelerationStructuresPropertiesKHR(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery); } template VKAPI_ATTR void VKAPI_CALL vkGetDeviceAccelerationStructureCompatibilityKHR(VkDevice device, const VkAccelerationStructureVersionInfoKHR* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetDeviceAccelerationStructureCompatibilityKHR", "device, pVersionInfo, pCompatibility", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceAccelerationStructureCompatibilityKHR(ApiDumpInstance::current(), device, pVersionInfo, pCompatibility); - } - } - device_dispatch_table(device)->GetDeviceAccelerationStructureCompatibilityKHR(device, pVersionInfo, pCompatibility); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetDeviceAccelerationStructureCompatibilityKHR(ApiDumpInstance::current(), device, pVersionInfo, pCompatibility); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetDeviceAccelerationStructureCompatibilityKHR\n"; } + device_dispatch_table(device)->GetDeviceAccelerationStructureCompatibilityKHR(device, pVersionInfo, pCompatibility); } template VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureBuildSizesKHR(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetAccelerationStructureBuildSizesKHR", "device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetAccelerationStructureBuildSizesKHR(ApiDumpInstance::current(), device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo); - } - } - device_dispatch_table(device)->GetAccelerationStructureBuildSizesKHR(device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetAccelerationStructureBuildSizesKHR(ApiDumpInstance::current(), device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetAccelerationStructureBuildSizesKHR\n"; } + device_dispatch_table(device)->GetAccelerationStructureBuildSizesKHR(device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdTraceRaysKHR", "commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdTraceRaysKHR(ApiDumpInstance::current(), commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth); - } - } - device_dispatch_table(commandBuffer)->CmdTraceRaysKHR(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdTraceRaysKHR(ApiDumpInstance::current(), commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdTraceRaysKHR\n"; } + device_dispatch_table(commandBuffer)->CmdTraceRaysKHR(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateRayTracingPipelinesKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCreateRayTracingPipelinesKHR", "device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateRayTracingPipelinesKHR(ApiDumpInstance::current(), device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); - } - } - VkResult result = device_dispatch_table(device)->CreateRayTracingPipelinesKHR(device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCreateRayTracingPipelinesKHR(ApiDumpInstance::current(), device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCreateRayTracingPipelinesKHR\n"; } + VkResult result = device_dispatch_table(device)->CreateRayTracingPipelinesKHR(device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR", "device, pipeline, firstGroup, groupCount, dataSize, pData", "VkResult"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(ApiDumpInstance::current(), device, pipeline, firstGroup, groupCount, dataSize, pData); - } - } - VkResult result = device_dispatch_table(device)->GetRayTracingCaptureReplayShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount, dataSize, pData); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkResult", result, dump_return_value_VkResult); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(ApiDumpInstance::current(), device, pipeline, firstGroup, groupCount, dataSize, pData); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR\n"; } + VkResult result = device_dispatch_table(device)->GetRayTracingCaptureReplayShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount, dataSize, pData); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysIndirectKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdTraceRaysIndirectKHR", "commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdTraceRaysIndirectKHR(ApiDumpInstance::current(), commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress); - } - } - device_dispatch_table(commandBuffer)->CmdTraceRaysIndirectKHR(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdTraceRaysIndirectKHR(ApiDumpInstance::current(), commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdTraceRaysIndirectKHR\n"; } + device_dispatch_table(commandBuffer)->CmdTraceRaysIndirectKHR(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress); } template VKAPI_ATTR VkDeviceSize VKAPI_CALL vkGetRayTracingShaderGroupStackSizeKHR(VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkGetRayTracingShaderGroupStackSizeKHR", "device, pipeline, group, groupShader", "VkDeviceSize"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetRayTracingShaderGroupStackSizeKHR(ApiDumpInstance::current(), device, pipeline, group, groupShader); - } - } - VkDeviceSize result = device_dispatch_table(device)->GetRayTracingShaderGroupStackSizeKHR(device, pipeline, group, groupShader); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_return_value(ApiDumpInstance::current().settings(), "VkDeviceSize", result); - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkGetRayTracingShaderGroupStackSizeKHR(ApiDumpInstance::current(), device, pipeline, group, groupShader); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkGetRayTracingShaderGroupStackSizeKHR\n"; } + VkDeviceSize result = device_dispatch_table(device)->GetRayTracingShaderGroupStackSizeKHR(device, pipeline, group, groupShader); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdSetRayTracingPipelineStackSizeKHR", "commandBuffer, pipelineStackSize", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetRayTracingPipelineStackSizeKHR(ApiDumpInstance::current(), commandBuffer, pipelineStackSize); - } - } - device_dispatch_table(commandBuffer)->CmdSetRayTracingPipelineStackSizeKHR(commandBuffer, pipelineStackSize); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdSetRayTracingPipelineStackSizeKHR(ApiDumpInstance::current(), commandBuffer, pipelineStackSize); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdSetRayTracingPipelineStackSizeKHR\n"; } + device_dispatch_table(commandBuffer)->CmdSetRayTracingPipelineStackSizeKHR(commandBuffer, pipelineStackSize); } template VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksEXT(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdDrawMeshTasksEXT", "commandBuffer, groupCountX, groupCountY, groupCountZ", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDrawMeshTasksEXT(ApiDumpInstance::current(), commandBuffer, groupCountX, groupCountY, groupCountZ); - } - } - device_dispatch_table(commandBuffer)->CmdDrawMeshTasksEXT(commandBuffer, groupCountX, groupCountY, groupCountZ); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDrawMeshTasksEXT(ApiDumpInstance::current(), commandBuffer, groupCountX, groupCountY, groupCountZ); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdDrawMeshTasksEXT\n"; } + device_dispatch_table(commandBuffer)->CmdDrawMeshTasksEXT(commandBuffer, groupCountX, groupCountY, groupCountZ); } template VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectEXT(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdDrawMeshTasksIndirectEXT", "commandBuffer, buffer, offset, drawCount, stride", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDrawMeshTasksIndirectEXT(ApiDumpInstance::current(), commandBuffer, buffer, offset, drawCount, stride); - } - } - device_dispatch_table(commandBuffer)->CmdDrawMeshTasksIndirectEXT(commandBuffer, buffer, offset, drawCount, stride); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDrawMeshTasksIndirectEXT(ApiDumpInstance::current(), commandBuffer, buffer, offset, drawCount, stride); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdDrawMeshTasksIndirectEXT\n"; } + device_dispatch_table(commandBuffer)->CmdDrawMeshTasksIndirectEXT(commandBuffer, buffer, offset, drawCount, stride); } template VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectCountEXT(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "vkCmdDrawMeshTasksIndirectCountEXT", "commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride", "void"); - if constexpr (Format == ApiDumpFormat::Text) { - if (ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) { - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDrawMeshTasksIndirectCountEXT(ApiDumpInstance::current(), commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); - } - } - device_dispatch_table(commandBuffer)->CmdDrawMeshTasksIndirectCountEXT(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); if (ApiDumpInstance::current().shouldDumpOutput()) { - dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_vkCmdDrawMeshTasksIndirectCountEXT(ApiDumpInstance::current(), commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); + ApiDumpInstance::current().settings().stream() << "vkCmdDrawMeshTasksIndirectCountEXT\n"; } + device_dispatch_table(commandBuffer)->CmdDrawMeshTasksIndirectCountEXT(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); } template diff --git a/layersvt/generated/api_dump_implementation.h b/layersvt/generated/api_dump_implementation.h index 8ea2576d11..6d391f38b5 100644 --- a/layersvt/generated/api_dump_implementation.h +++ b/layersvt/generated/api_dump_implementation.h @@ -3303,9 +3303,6 @@ void dump_VkStructureType(const VkStructureType object, const ApiDumpSettings& s case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT: dump_enum(settings, "VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT", static_cast(object)); break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM: - dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM", static_cast(object)); - break; case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: dump_enum(settings, "VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT", static_cast(object)); break; @@ -33742,19 +33739,6 @@ void dump_VkFilterCubicImageViewImageFormatPropertiesEXT(const VkFilterCubicImag dump_end(settings, OutputConstruct::api_struct, indents); } template -void dump_VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM(const VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { - dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); - dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); - dump_separate_members(settings); - dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); - dump_separate_members(settings); - dump_type(object.cooperativeMatrixConversion, settings, "VkBool32", "cooperativeMatrixConversion", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); - if constexpr (Format == ApiDumpFormat::Text) { - dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); - } - dump_end(settings, OutputConstruct::api_struct, indents); -} -template void dump_VkImportMemoryHostPointerInfoEXT(const VkImportMemoryHostPointerInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); @@ -45746,10 +45730,6 @@ void dump_pNext_struct_name(const void* object, const ApiDumpSettings& settings, dump_string(settings, "VkFilterCubicImageViewImageFormatPropertiesEXT"); break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM: - dump_string(settings, "VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM"); - break; - case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: dump_string(settings, "VkImportMemoryHostPointerInfoEXT"); break; @@ -50478,10 +50458,6 @@ void dump_pNext_trampoline(const void* object, const ApiDumpSettings& settings, dump_VkFilterCubicImageViewImageFormatPropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkFilterCubicImageViewImageFormatPropertiesEXT*" : "VkFilterCubicImageViewImageFormatPropertiesEXT"), "pNext", indents, reinterpret_cast(object)); break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM: - dump_VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM*" : "VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM"), "pNext", indents, reinterpret_cast(object)); - break; - case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: dump_VkImportMemoryHostPointerInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImportMemoryHostPointerInfoEXT*" : "VkImportMemoryHostPointerInfoEXT"), "pNext", indents, reinterpret_cast(object)); break; diff --git a/scripts/generators/api_dump_generator.py b/scripts/generators/api_dump_generator.py index 10e81dcf13..5197ae1b14 100644 --- a/scripts/generators/api_dump_generator.py +++ b/scripts/generators/api_dump_generator.py @@ -384,12 +384,8 @@ def generate_dispatch_codegen(self): if command.name not in BLOCKING_API_CALLS: self.write(f''' std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - dump_function_head(ApiDumpInstance::current(), "{command.name}", "{command_param_usage_text(command)}", "{command.returnType}"); - if constexpr (Format == ApiDumpFormat::Text) {{ - if(ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {{ - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_{command.name}(ApiDumpInstance::current(), {command_param_usage_text(command)}); - }} + if (ApiDumpInstance::current().shouldDumpOutput()) {{ + ApiDumpInstance::current().settings().stream() << "{command.name}\\n"; }}''') if command.name == 'vkGetPhysicalDeviceToolPropertiesEXT': @@ -416,7 +412,9 @@ def generate_dispatch_codegen(self): self.write(f'{return_str}instance_dispatch_table({command.params[0].name})->{command.name[2:]}({command_param_usage_text(command)});') if command.name in BLOCKING_API_CALLS: self.write('std::lock_guard lg(ApiDumpInstance::current().outputMutex());') - self.write(f'dump_function_head(ApiDumpInstance::current(), "{command.name}", "{command_param_usage_text(command)}", "{command.returnType}");') + self.write(f'''if (ApiDumpInstance::current().shouldDumpOutput()) {{ + ApiDumpInstance::current().settings().stream() << "{command.name}\\n"; + }}''') if command.name in TRACKED_STATE: self.write(TRACKED_STATE[command.name]) @@ -438,17 +436,7 @@ def generate_dispatch_codegen(self): self.write('}\n') self.write('(*pToolCount)++;') - self.write('if (ApiDumpInstance::current().shouldDumpOutput()) {') - if command.returnType != 'void': - if self.get_unaliased_type(command.returnType) in self.vulkan_defined_types: - self.write(f'dump_return_value(ApiDumpInstance::current().settings(), "{command.returnType}", result, dump_return_value_{command.returnType});') - else: - self.write(f'dump_return_value(ApiDumpInstance::current().settings(), "{command.returnType}", result);') - self.write(f'''dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_{command.name}(ApiDumpInstance::current(), {command_param_usage_text(command)}); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); - }}''') + if command.returnType != 'void': self.write('return result;') self.write('}') @@ -471,19 +459,17 @@ def generate_dispatch_codegen(self): if command.name in ['vkDebugMarkerSetObjectNameEXT', 'vkSetDebugUtilsObjectNameEXT']: self.write('ApiDumpInstance::current().update_object_name_map(pNameInfo);') self.write(f''' - dump_function_head(ApiDumpInstance::current(), "{command.name}", "{command_param_usage_text(command)}", "{command.returnType}"); - if constexpr (Format == ApiDumpFormat::Text) {{ - if(ApiDumpInstance::current().settings().shouldPreDump() && ApiDumpInstance::current().shouldDumpOutput()) {{ - dump_before_pre_dump_formatting(ApiDumpInstance::current().settings()); - dump_params_{command.name}(ApiDumpInstance::current(), {command_param_usage_text(command)}); - }} + if (ApiDumpInstance::current().shouldDumpOutput()) {{ + ApiDumpInstance::current().settings().stream() << "{command.name}\\n"; }}''') return_str = f'{command.returnType} result = ' if command.returnType != 'void' else '' self.write(f'{return_str}device_dispatch_table({command.params[0].name})->{command.name[2:]}({command_param_usage_text(command)});') if command.name in BLOCKING_API_CALLS: self.write('std::lock_guard lg(ApiDumpInstance::current().outputMutex());') - self.write(f'dump_function_head(ApiDumpInstance::current(), "{command.name}", "{command_param_usage_text(command)}", "{command.returnType}");') + self.write(f'''if (ApiDumpInstance::current().shouldDumpOutput()) {{ + ApiDumpInstance::current().settings().stream() << "{command.name}\\n"; + }}''') if command.name in TRACKED_STATE: self.write('' + TRACKED_STATE[command.name]) @@ -491,19 +477,7 @@ def generate_dispatch_codegen(self): if command.name == 'vkDestroyDevice': self.write('destroy_device_dispatch_table(get_dispatch_key(device));') - self.write('if (ApiDumpInstance::current().shouldDumpOutput()) {') - if command.returnType != 'void': - return_type = self.get_unaliased_type(command.returnType) - if return_type in self.vulkan_defined_types or return_type == 'VkDeviceAddress': - self.write(f'dump_return_value(ApiDumpInstance::current().settings(), "{command.returnType}", result, dump_return_value_{command.returnType});') - else: - self.write(f'dump_return_value(ApiDumpInstance::current().settings(), "{command.returnType}", result);') - self.write(f'''dump_pre_function_formatting(ApiDumpInstance::current().settings()); - dump_params_{command.name}(ApiDumpInstance::current(), {command_param_usage_text(command)}); - dump_post_function_formatting(ApiDumpInstance::current().settings()); - flush(ApiDumpInstance::current().settings()); - }}''') if command.name == 'vkQueuePresentKHR': self.write('ApiDumpInstance::current().nextFrame();') From 58c1e862e289c0fce749c176f9164d31beea42a6 Mon Sep 17 00:00:00 2001 From: Emre Kultursay Date: Thu, 26 Feb 2026 09:44:51 -0800 Subject: [PATCH 03/14] Add a simple cputiming layer that does nothing --- CMakeLists.txt | 4 +- layersvt/CMakeLists.txt | 15 +- layersvt/cputiming.cpp | 538 ++++++++++++++++++++++++ layersvt/json/VkLayer_CPUTiming.json.in | 28 ++ 4 files changed, 583 insertions(+), 2 deletions(-) create mode 100644 layersvt/cputiming.cpp create mode 100644 layersvt/json/VkLayer_CPUTiming.json.in diff --git a/CMakeLists.txt b/CMakeLists.txt index 4f31125309..1e4780ee15 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -92,6 +92,7 @@ if (CMAKE_SYSTEM_NAME MATCHES "Windows|Linux|BSD") option(BUILD_APIDUMP "Build api_dump layer" ON) option(BUILD_MONITOR "Build monitor layer" ON) option(BUILD_SCREENSHOT "Build screenshot layer" ON) + option(BUILD_CPUTIMING "Build CPUTiming layer" ON) option(BUILD_LAYERMGR "Build Vulkan Configurator" ON) set(SDK_VERSION "" CACHE STRING "Vulkan SDK version") @@ -102,6 +103,7 @@ elseif(ANDROID) # - libVkLayer_screenshot.so option(BUILD_APIDUMP "Build api_dump layer" ON) option(BUILD_SCREENSHOT "Build screenshot layer" ON) + option(BUILD_CPUTIMING "Build CPUTiming layer" ON) set(BUILD_MONITOR OFF) set(BUILD_LAYERMGR OFF) @@ -121,7 +123,7 @@ if(BUILD_TESTS) add_subdirectory(tests) endif() -if(BUILD_APIDUMP OR BUILD_MONITOR OR BUILD_SCREENSHOT) +if(BUILD_APIDUMP OR BUILD_MONITOR OR BUILD_SCREENSHOT OR BUILD_CPUTIMING) message(STATUS "INFO: Building Vulkan Layers") add_subdirectory(layersvt) endif() diff --git a/layersvt/CMakeLists.txt b/layersvt/CMakeLists.txt index 43d24d685b..24f8dd8f70 100644 --- a/layersvt/CMakeLists.txt +++ b/layersvt/CMakeLists.txt @@ -7,6 +7,7 @@ if(WIN32) add_compile_definitions(NOMINMAX WIN32_LEAN_AND_MEAN) elseif(ANDROID) add_compile_definitions(VK_USE_PLATFORM_ANDROID_KHR) + option(BUILD_CPUTIMING "Build CPUTiming layer" ON) elseif(APPLE) if (CMAKE_SYSTEM_NAME STREQUAL "Darwin") add_compile_definitions(VK_USE_PLATFORM_MACOS_MVK) @@ -17,6 +18,7 @@ elseif(APPLE) elseif(CMAKE_SYSTEM_NAME MATCHES "Linux|BSD|DragonFly|GNU") option(BUILD_WSI_XCB_SUPPORT "Build XCB WSI support" ON) option(BUILD_WSI_WAYLAND_SUPPORT "Build WAYLAND WSI support" ON) + option(BUILD_CPUTIMING "Build CPUTiming layer" ON) find_package(PkgConfig REQUIRED) @@ -116,11 +118,22 @@ if(BUILD_SCREENSHOT) ) endif() +if(BUILD_CPUTIMING) + add_library(VkLayer_CPUTiming MODULE) + set_target_properties(VkLayer_CPUTiming PROPERTIES FOLDER "layers/cputiming") + target_sources(VkLayer_CPUTiming PRIVATE + cputiming.cpp + vk_layer_table.cpp + vk_layer_table.h + json/VkLayer_CPUTiming.json.in + ) +endif() + if (BUILD_TESTS AND NOT RUN_ON_GITHUB) add_subdirectory(test) endif() -list(APPEND TOOL_LAYERS "VkLayer_api_dump" "VkLayer_screenshot" "VkLayer_monitor") +list(APPEND TOOL_LAYERS "VkLayer_api_dump" "VkLayer_screenshot" "VkLayer_monitor" "VkLayer_CPUTiming") foreach(layer ${TOOL_LAYERS}) if (NOT TARGET "${layer}") continue() diff --git a/layersvt/cputiming.cpp b/layersvt/cputiming.cpp new file mode 100644 index 0000000000..228a952c2b --- /dev/null +++ b/layersvt/cputiming.cpp @@ -0,0 +1,538 @@ +/* + * Copyright (C) 2015-2021 Valve Corporation + * Copyright (C) 2015-2021 LunarG, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * Author: Cody Northrop + * Author: David Pinedo + * Author: Jon Ashburn + * Author: Tony Barbour + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include "vk_layer_table.h" + +#ifdef ANDROID +#include +#include +#endif + +namespace cputiming { + +#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0])) + +std::mutex globalLock; + +VkuLayerSettingSet globalLayerSettingSet = VK_NULL_HANDLE; + +// unordered map: associates Vulkan dispatchable objects to a dispatch table +typedef struct { + VkuDeviceDispatchTable *device_dispatch_table; + PFN_vkSetDeviceLoaderData pfn_dev_init; +} DispatchMapStruct; +static std::unordered_map dispatchMap; + +// unordered map: associates a device with per device info - +// wsi capability +// set of queues created for this device +// queue to queueFamilyIndex map +// physical device +struct DeviceMapStruct { + bool wsi_enabled; + std::set queues; + std::unordered_map queueIndexMap; + VkPhysicalDevice physicalDevice; +}; +static std::unordered_map deviceMap; + +// unordered map: associates a physical device with an instance +typedef struct { + VkInstance instance; +} PhysDeviceMapStruct; +static std::unordered_map physDeviceMap; + +static void LogMessage(const char* format, ...) { + va_list args; + va_start(args, format); +#ifdef ANDROID + __android_log_vprint(ANDROID_LOG_INFO, "CPUTiming", format, args); +#else + vprintf(format, args); + printf("\n"); +#endif + va_end(args); +} + +static DispatchMapStruct *get_dispatch_info(VkDevice dev) { + auto it = dispatchMap.find(dev); + if (it == dispatchMap.end()) + return NULL; + else + return it->second; +} + +static DeviceMapStruct *get_device_info(VkDevice dev) { + auto it = deviceMap.find(dev); + if (it == deviceMap.end()) + return NULL; + else + return it->second; +} + +static void init_cputiming(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator) { + std::lock_guard lg(globalLock); + // keeping layer settings structure if we ever need it, but currently unused + // logic simplified +} + +static void shutdown_cputiming() { + // cleanup if needed +} + +VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, + VkInstance *pInstance) { + LogMessage("CreateInstance"); + VkLayerInstanceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO); + + assert(chain_info->u.pLayerInfo); + PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr; + assert(fpGetInstanceProcAddr); + PFN_vkCreateInstance fpCreateInstance = (PFN_vkCreateInstance)fpGetInstanceProcAddr(VK_NULL_HANDLE, "vkCreateInstance"); + if (fpCreateInstance == NULL) { + return VK_ERROR_INITIALIZATION_FAILED; + } + + // Advance the link info for the next element on the chain + chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext; + + VkResult result = fpCreateInstance(pCreateInfo, pAllocator, pInstance); + if (result != VK_SUCCESS) return result; + + initInstanceTable(*pInstance, fpGetInstanceProcAddr); + init_cputiming(pCreateInfo, pAllocator); + + return result; +} + +VKAPI_ATTR void VKAPI_CALL DestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) { + LogMessage("DestroyInstance"); + shutdown_cputiming(); + + VkuInstanceDispatchTable *pTable = instance_dispatch_table(instance); + pTable->DestroyInstance(instance, pAllocator); +} + +static void createDeviceRegisterExtensions(const VkDeviceCreateInfo *pCreateInfo, VkDevice device) { + uint32_t i; + DispatchMapStruct *dispMap = get_dispatch_info(device); + DeviceMapStruct *devMap = get_device_info(device); + VkuDeviceDispatchTable *pDisp = dispMap->device_dispatch_table; + PFN_vkGetDeviceProcAddr gpa = pDisp->GetDeviceProcAddr; + pDisp->CreateSwapchainKHR = (PFN_vkCreateSwapchainKHR)gpa(device, "vkCreateSwapchainKHR"); + pDisp->GetSwapchainImagesKHR = (PFN_vkGetSwapchainImagesKHR)gpa(device, "vkGetSwapchainImagesKHR"); + pDisp->AcquireNextImageKHR = (PFN_vkAcquireNextImageKHR)gpa(device, "vkAcquireNextImageKHR"); + pDisp->QueuePresentKHR = (PFN_vkQueuePresentKHR)gpa(device, "vkQueuePresentKHR"); + devMap->wsi_enabled = false; + for (i = 0; i < pCreateInfo->enabledExtensionCount; i++) { + if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_SWAPCHAIN_EXTENSION_NAME) == 0) devMap->wsi_enabled = true; + } +} + +VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo *pCreateInfo, + const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) { + LogMessage("CreateDevice"); + VkLayerDeviceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO); + + assert(chain_info->u.pLayerInfo); + PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr; + PFN_vkGetDeviceProcAddr fpGetDeviceProcAddr = chain_info->u.pLayerInfo->pfnNextGetDeviceProcAddr; + VkInstance instance = physDeviceMap[gpu].instance; + PFN_vkCreateDevice fpCreateDevice = (PFN_vkCreateDevice)fpGetInstanceProcAddr(instance, "vkCreateDevice"); + if (fpCreateDevice == NULL) { + return VK_ERROR_INITIALIZATION_FAILED; + } + + // Advance the link info for the next element on the chain + chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext; + + VkResult result = fpCreateDevice(gpu, pCreateInfo, pAllocator, pDevice); + if (result != VK_SUCCESS) { + return result; + } + + assert(deviceMap.find(*pDevice) == deviceMap.end()); + DeviceMapStruct *deviceMapElem = new DeviceMapStruct; + deviceMap[*pDevice] = deviceMapElem; + assert(dispatchMap.find(*pDevice) == dispatchMap.end()); + DispatchMapStruct *dispatchMapElem = new DispatchMapStruct; + dispatchMap[*pDevice] = dispatchMapElem; + + // Setup device dispatch table + dispatchMapElem->device_dispatch_table = new VkuDeviceDispatchTable; + vkuInitDeviceDispatchTable(*pDevice, dispatchMapElem->device_dispatch_table, fpGetDeviceProcAddr); + + createDeviceRegisterExtensions(pCreateInfo, *pDevice); + // Create a mapping from a device to a physicalDevice + deviceMapElem->physicalDevice = gpu; + + // store the loader callback for initializing created dispatchable objects + chain_info = get_chain_info(pCreateInfo, VK_LOADER_DATA_CALLBACK); + if (chain_info) { + dispatchMapElem->pfn_dev_init = chain_info->u.pfnSetDeviceLoaderData; + } else { + dispatchMapElem->pfn_dev_init = NULL; + } + return result; +} + +VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, + VkPhysicalDevice *pPhysicalDevices) { + LogMessage("EnumeratePhysicalDevices"); + VkResult result; + + VkuInstanceDispatchTable *pTable = instance_dispatch_table(instance); + result = pTable->EnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices); + if (result == VK_SUCCESS && *pPhysicalDeviceCount > 0 && pPhysicalDevices) { + for (uint32_t i = 0; i < *pPhysicalDeviceCount; i++) { + // Create a mapping from a physicalDevice to an instance + physDeviceMap[pPhysicalDevices[i]].instance = instance; + } + } + return result; +} + +VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, + VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties) { + LogMessage("EnumeratePhysicalDeviceGroups"); + VkResult result; + VkuInstanceDispatchTable *pTable = instance_dispatch_table(instance); + result = pTable->EnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); + if (result == VK_SUCCESS && *pPhysicalDeviceGroupCount > 0 && pPhysicalDeviceGroupProperties) { + for (uint32_t i = 0; i < *pPhysicalDeviceGroupCount; i++) { + for (uint32_t j = 0; j < pPhysicalDeviceGroupProperties[i].physicalDeviceCount; j++) { + // Create a mapping from each physicalDevice to an instance + physDeviceMap[pPhysicalDeviceGroupProperties[i].physicalDevices[j]].instance = instance; + } + } + } + return VK_SUCCESS; +} + +VKAPI_ATTR void VKAPI_CALL DestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) { + LogMessage("DestroyDevice"); + DispatchMapStruct *dispMap = get_dispatch_info(device); + DeviceMapStruct *devMap = get_device_info(device); + assert(dispMap); + assert(devMap); + VkuDeviceDispatchTable *pDisp = dispMap->device_dispatch_table; + pDisp->DestroyDevice(device, pAllocator); + + std::lock_guard lg(globalLock); + delete pDisp; + delete dispMap; + delete devMap; + + deviceMap.erase(device); + dispatchMap.erase(device); +} + +VKAPI_ATTR void VKAPI_CALL GetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue) { + LogMessage("GetDeviceQueue"); + DispatchMapStruct *dispMap = get_dispatch_info(device); + assert(dispMap); + VkuDeviceDispatchTable *pDisp = dispMap->device_dispatch_table; + pDisp->GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue); + + std::lock_guard lg(globalLock); + + // Add this queue to deviceMap[device].queues, and queueFamilyIndex to deviceMap[device].queueIndexMap + if (deviceMap.find(device) != deviceMap.end()) { + deviceMap[device]->queues.emplace(*pQueue); + + if (deviceMap[device]->queueIndexMap.find(*pQueue) != deviceMap[device]->queueIndexMap.end()) + deviceMap[device]->queueIndexMap.erase(*pQueue); + deviceMap[device]->queueIndexMap.emplace(*pQueue, queueFamilyIndex); + } + + // queues are dispatchable objects. + // Create dispatchMap entry with this queue as its key. + // Copy the device dispatch table to the new dispatch table. + VkDevice que = static_cast(static_cast(*pQueue)); + dispatchMap[que] = dispMap; +} + +VKAPI_ATTR void VKAPI_CALL GetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue) { + LogMessage("GetDeviceQueue2"); + if (pQueueInfo) GetDeviceQueue(device, pQueueInfo->queueFamilyIndex, pQueueInfo->queueIndex, pQueue); +} + +VKAPI_ATTR VkResult VKAPI_CALL CreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, + const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain) { + LogMessage("CreateSwapchainKHR"); + DispatchMapStruct *dispMap = get_dispatch_info(device); + assert(dispMap); + VkuDeviceDispatchTable *pDisp = dispMap->device_dispatch_table; + + VkResult result = pDisp->CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain); + return result; +} + +VKAPI_ATTR void DestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator) { + LogMessage("DestroySwapchainKHR"); + DispatchMapStruct *dispMap = get_dispatch_info(device); + assert(dispMap); + VkuDeviceDispatchTable *pDisp = dispMap->device_dispatch_table; + pDisp->DestroySwapchainKHR(device, swapchain, pAllocator); +} + +VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pCount, + VkImage *pSwapchainImages) { + LogMessage("GetSwapchainImagesKHR"); + DispatchMapStruct *dispMap = get_dispatch_info(device); + assert(dispMap); + VkuDeviceDispatchTable *pDisp = dispMap->device_dispatch_table; + VkResult result = pDisp->GetSwapchainImagesKHR(device, swapchain, pCount, pSwapchainImages); + return result; +} + +VKAPI_ATTR VkResult VKAPI_CALL QueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo) { + LogMessage("QueuePresentKHR"); + DispatchMapStruct *dispMap = get_dispatch_info((VkDevice)queue); + VkuDeviceDispatchTable *pDisp = dispMap->device_dispatch_table; + assert(dispMap); + VkResult result = pDisp->QueuePresentKHR(queue, pPresentInfo); + return result; +} + +static const VkLayerProperties global_layer = { + "CPUTiming", // layerName + VK_MAKE_VERSION(1, 0, 0), // specVersion + 1, // implementationVersion + "Layer: CPUTiming", // description +}; + +VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceLayerProperties(uint32_t *pCount, VkLayerProperties *pProperties) { + return util_GetLayerProperties(1, &global_layer, pCount, pProperties); +} + +VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount, + VkLayerProperties *pProperties) { + return util_GetLayerProperties(1, &global_layer, pCount, pProperties); +} + +VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount, + VkExtensionProperties *pProperties) { + if (pLayerName && !strcmp(pLayerName, global_layer.layerName)) return util_GetExtensionProperties(0, NULL, pCount, pProperties); + + return VK_ERROR_LAYER_NOT_PRESENT; +} + +VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName, + uint32_t *pCount, VkExtensionProperties *pProperties) { + if (pLayerName && !strcmp(pLayerName, global_layer.layerName)) return util_GetExtensionProperties(0, NULL, pCount, pProperties); + + assert(physicalDevice); + + VkuInstanceDispatchTable *pTable = instance_dispatch_table(physicalDevice); + return pTable->EnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pCount, pProperties); +} + +VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceToolPropertiesEXT(VkPhysicalDevice physicalDevice, uint32_t *pToolCount, + VkPhysicalDeviceToolPropertiesEXT *pToolProperties) { + LogMessage("GetPhysicalDeviceToolPropertiesEXT"); + static const VkPhysicalDeviceToolPropertiesEXT cputiming_layer_tool_props = { + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT, + nullptr, + "CPUTiming Layer", + "1", + VK_TOOL_PURPOSE_PROFILING_BIT_EXT | VK_TOOL_PURPOSE_TRACING_BIT_EXT | VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT_EXT, + "The VK_LAYER_CPUTiming layer prints API calls.", + "VK_LAYER_CPUTiming"}; + + auto original_pToolProperties = pToolProperties; + if (pToolProperties != nullptr) { + *pToolProperties = cputiming_layer_tool_props; + pToolProperties = ((*pToolCount > 1) ? &pToolProperties[1] : nullptr); + (*pToolCount)--; + } + + VkuInstanceDispatchTable *pInstanceTable = instance_dispatch_table(physicalDevice); + VkResult result = pInstanceTable->GetPhysicalDeviceToolPropertiesEXT(physicalDevice, pToolCount, pToolProperties); + + if (original_pToolProperties != nullptr) { + pToolProperties = original_pToolProperties; + } + + (*pToolCount)++; + + return result; +} + +static PFN_vkVoidFunction intercept_core_instance_command(const char *name); + +static PFN_vkVoidFunction intercept_core_device_command(const char *name); + +static PFN_vkVoidFunction intercept_khr_swapchain_command(const char *name, VkDevice dev); + +VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(VkDevice dev, const char *funcName) { + PFN_vkVoidFunction proc = intercept_core_device_command(funcName); + if (proc) return proc; + + if (dev == NULL) { + return NULL; + } + + proc = intercept_khr_swapchain_command(funcName, dev); + if (proc) return proc; + + DispatchMapStruct *dispMap = get_dispatch_info(dev); + assert(dispMap); + VkuDeviceDispatchTable *pDisp = dispMap->device_dispatch_table; + + if (pDisp->GetDeviceProcAddr == NULL) return NULL; + return pDisp->GetDeviceProcAddr(dev, funcName); +} + +VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(VkInstance instance, const char *funcName) { + PFN_vkVoidFunction proc = intercept_core_instance_command(funcName); + if (proc) return proc; + + assert(instance); + + proc = intercept_core_device_command(funcName); + if (!proc) proc = intercept_khr_swapchain_command(funcName, VK_NULL_HANDLE); + if (proc) return proc; + + VkuInstanceDispatchTable *pTable = instance_dispatch_table(instance); + if (pTable->GetInstanceProcAddr == NULL) return NULL; + return pTable->GetInstanceProcAddr(instance, funcName); +} + +static PFN_vkVoidFunction intercept_core_instance_command(const char *name) { + static const struct { + const char *name; + PFN_vkVoidFunction proc; + } core_instance_commands[] = { + {"vkGetInstanceProcAddr", reinterpret_cast(GetInstanceProcAddr)}, + {"vkCreateInstance", reinterpret_cast(CreateInstance)}, + {"vkDestroyInstance", reinterpret_cast(DestroyInstance)}, + {"vkCreateDevice", reinterpret_cast(CreateDevice)}, + {"vkEnumeratePhysicalDevices", reinterpret_cast(EnumeratePhysicalDevices)}, + {"vkEnumeratePhysicalDeviceGroups", reinterpret_cast(EnumeratePhysicalDeviceGroups)}, + {"vkEnumerateInstanceLayerProperties", reinterpret_cast(EnumerateInstanceLayerProperties)}, + {"vkEnumerateDeviceLayerProperties", reinterpret_cast(EnumerateDeviceLayerProperties)}, + {"vkEnumerateInstanceExtensionProperties", reinterpret_cast(EnumerateInstanceExtensionProperties)}, + {"vkEnumerateDeviceExtensionProperties", reinterpret_cast(EnumerateDeviceExtensionProperties)}, + {"vkGetPhysicalDeviceToolPropertiesEXT", reinterpret_cast(GetPhysicalDeviceToolPropertiesEXT)}}; + + for (size_t i = 0; i < ARRAY_SIZE(core_instance_commands); i++) { + if (!strcmp(core_instance_commands[i].name, name)) return core_instance_commands[i].proc; + } + + return nullptr; +} + +static PFN_vkVoidFunction intercept_core_device_command(const char *name) { + static const struct { + const char *name; + PFN_vkVoidFunction proc; + } core_device_commands[] = { + {"vkGetDeviceProcAddr", reinterpret_cast(GetDeviceProcAddr)}, + {"vkGetDeviceQueue", reinterpret_cast(GetDeviceQueue)}, + {"vkGetDeviceQueue2", reinterpret_cast(GetDeviceQueue2)}, + {"vkDestroyDevice", reinterpret_cast(DestroyDevice)}, + }; + + for (size_t i = 0; i < ARRAY_SIZE(core_device_commands); i++) { + if (!strcmp(core_device_commands[i].name, name)) return core_device_commands[i].proc; + } + + return nullptr; +} + +static PFN_vkVoidFunction intercept_khr_swapchain_command(const char *name, VkDevice dev) { + static const struct { + const char *name; + PFN_vkVoidFunction proc; + } khr_swapchain_commands[] = { + {"vkCreateSwapchainKHR", reinterpret_cast(CreateSwapchainKHR)}, + {"vkDestroySwapchainKHR", reinterpret_cast(DestroySwapchainKHR)}, + {"vkQueuePresentKHR", reinterpret_cast(QueuePresentKHR)}, + }; + + if (dev) { + DeviceMapStruct *devMap = get_device_info(dev); + if (!devMap->wsi_enabled) return nullptr; + } + + for (size_t i = 0; i < ARRAY_SIZE(khr_swapchain_commands); i++) { + if (!strcmp(khr_swapchain_commands[i].name, name)) return khr_swapchain_commands[i].proc; + } + + return nullptr; +} + +} // namespace cputiming + +#if defined(__GNUC__) && __GNUC__ >= 4 +#define EXPORT_FUNCTION __attribute__((visibility("default"))) +#elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590) +#define EXPORT_FUNCTION __attribute__((visibility("default"))) +#else +#define EXPORT_FUNCTION +#endif + +EXPORT_FUNCTION VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(uint32_t *pCount, + VkLayerProperties *pProperties) { + return cputiming::EnumerateInstanceLayerProperties(pCount, pProperties); +} + +EXPORT_FUNCTION VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount, + VkLayerProperties *pProperties) { + assert(physicalDevice == VK_NULL_HANDLE); + return cputiming::EnumerateDeviceLayerProperties(VK_NULL_HANDLE, pCount, pProperties); +} + +EXPORT_FUNCTION VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount, + VkExtensionProperties *pProperties) { + return cputiming::EnumerateInstanceExtensionProperties(pLayerName, pCount, pProperties); +} + +EXPORT_FUNCTION VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, + const char *pLayerName, uint32_t *pCount, + VkExtensionProperties *pProperties) { + assert(physicalDevice == VK_NULL_HANDLE); + return cputiming::EnumerateDeviceExtensionProperties(VK_NULL_HANDLE, pLayerName, pCount, pProperties); +} + +EXPORT_FUNCTION VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice dev, const char *funcName) { + return cputiming::GetDeviceProcAddr(dev, funcName); +} + +EXPORT_FUNCTION VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance, const char *funcName) { + return cputiming::GetInstanceProcAddr(instance, funcName); +} diff --git a/layersvt/json/VkLayer_CPUTiming.json.in b/layersvt/json/VkLayer_CPUTiming.json.in new file mode 100644 index 0000000000..50b83e9956 --- /dev/null +++ b/layersvt/json/VkLayer_CPUTiming.json.in @@ -0,0 +1,28 @@ +{ + "file_format_version" : "1.2.0", + "layer": { + "name": "VK_LAYER_CPUTiming", + "type": "GLOBAL", + "library_path": "@JSON_LIBRARY_PATH@", + "api_version": "@JSON_VERSION@", + "implementation_version": "1", + "description": "CPUTiming layer", + "introduction": "The CPUTiming layer prints API calls.", + "platforms": [ "LINUX", "ANDROID" ], + "instance_extensions": [ + { + "name": "VK_EXT_layer_settings", + "spec_version": "2" + } + ], + "device_extensions": [ + { + "name": "VK_EXT_tooling_info", + "spec_version": "1", + "entrypoints": [ + "vkGetPhysicalDeviceToolPropertiesEXT" + ] + } + ] + } +} From 39fb690c9bd10007b346f4684e203ce8592366ca Mon Sep 17 00:00:00 2001 From: Emre Kultursay Date: Thu, 26 Feb 2026 10:19:44 -0800 Subject: [PATCH 04/14] Add a simple timer class --- layersvt/timer.h | 39 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 39 insertions(+) create mode 100644 layersvt/timer.h diff --git a/layersvt/timer.h b/layersvt/timer.h new file mode 100644 index 0000000000..ec81ecfff1 --- /dev/null +++ b/layersvt/timer.h @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2024 Your Company + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef LAYERSVT_TIMER_H +#define LAYERSVT_TIMER_H + +#include +#include +#include + +class Timer { + public: + explicit Timer(const char* name) : name_(name), start_(std::chrono::high_resolution_clock::now()) {} + + ~Timer() { + auto end = std::chrono::high_resolution_clock::now(); + auto duration = std::chrono::duration_cast(end - start_).count(); + std::cout << name_ << ": " << duration << " ns" << std::endl; + } + + private: + std::string name_; + std::chrono::time_point start_; +}; + +#endif // LAYERSVT_TIMER_H From 36ce5471d08bb65708940741ef35d1afc67c914e Mon Sep 17 00:00:00 2001 From: Emre Kultursay Date: Thu, 26 Feb 2026 10:25:48 -0800 Subject: [PATCH 05/14] Also print latency in api_dump layer --- layersvt/generated/api_dump_dispatch.h | 4536 ++++------------------ scripts/generators/api_dump_generator.py | 29 +- 2 files changed, 781 insertions(+), 3784 deletions(-) diff --git a/layersvt/generated/api_dump_dispatch.h b/layersvt/generated/api_dump_dispatch.h index 60fd4f868d..27a2575719 100644 --- a/layersvt/generated/api_dump_dispatch.h +++ b/layersvt/generated/api_dump_dispatch.h @@ -22,25 +22,20 @@ */ #include "api_dump_handwritten_functions.h" +#include "timer.h" // Autogen instance functions template VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyInstance\n"; - } + Timer timer("vkDestroyInstance"); auto dispatch_key = get_dispatch_key(instance); instance_dispatch_table(instance)->DestroyInstance(instance, pAllocator); destroy_instance_dispatch_table(dispatch_key); } template VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkEnumeratePhysicalDevices\n"; - } + Timer timer("vkEnumeratePhysicalDevices"); VkResult result = instance_dispatch_table(instance)->EnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices); if (pPhysicalDeviceCount != nullptr && pPhysicalDevices != nullptr) { @@ -52,292 +47,190 @@ VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices(VkInstance instance, u } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceFeatures\n"; - } + Timer timer("vkGetPhysicalDeviceFeatures"); instance_dispatch_table(physicalDevice)->GetPhysicalDeviceFeatures(physicalDevice, pFeatures); } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceFormatProperties\n"; - } + Timer timer("vkGetPhysicalDeviceFormatProperties"); instance_dispatch_table(physicalDevice)->GetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceImageFormatProperties\n"; - } + Timer timer("vkGetPhysicalDeviceImageFormatProperties"); VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties); return result; } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceProperties\n"; - } + Timer timer("vkGetPhysicalDeviceProperties"); instance_dispatch_table(physicalDevice)->GetPhysicalDeviceProperties(physicalDevice, pProperties); } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceQueueFamilyProperties\n"; - } + Timer timer("vkGetPhysicalDeviceQueueFamilyProperties"); instance_dispatch_table(physicalDevice)->GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceMemoryProperties\n"; - } + Timer timer("vkGetPhysicalDeviceMemoryProperties"); instance_dispatch_table(physicalDevice)->GetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties); } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceSparseImageFormatProperties\n"; - } + Timer timer("vkGetPhysicalDeviceSparseImageFormatProperties"); instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties); } template VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkEnumeratePhysicalDeviceGroups\n"; - } + Timer timer("vkEnumeratePhysicalDeviceGroups"); VkResult result = instance_dispatch_table(instance)->EnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); return result; } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceFeatures2\n"; - } + Timer timer("vkGetPhysicalDeviceFeatures2"); instance_dispatch_table(physicalDevice)->GetPhysicalDeviceFeatures2(physicalDevice, pFeatures); } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceProperties2\n"; - } + Timer timer("vkGetPhysicalDeviceProperties2"); instance_dispatch_table(physicalDevice)->GetPhysicalDeviceProperties2(physicalDevice, pProperties); } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceFormatProperties2\n"; - } + Timer timer("vkGetPhysicalDeviceFormatProperties2"); instance_dispatch_table(physicalDevice)->GetPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceImageFormatProperties2\n"; - } + Timer timer("vkGetPhysicalDeviceImageFormatProperties2"); VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceImageFormatProperties2(physicalDevice, pImageFormatInfo, pImageFormatProperties); return result; } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceQueueFamilyProperties2\n"; - } + Timer timer("vkGetPhysicalDeviceQueueFamilyProperties2"); instance_dispatch_table(physicalDevice)->GetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceMemoryProperties2\n"; - } + Timer timer("vkGetPhysicalDeviceMemoryProperties2"); instance_dispatch_table(physicalDevice)->GetPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties); } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceSparseImageFormatProperties2\n"; - } + Timer timer("vkGetPhysicalDeviceSparseImageFormatProperties2"); instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSparseImageFormatProperties2(physicalDevice, pFormatInfo, pPropertyCount, pProperties); } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceExternalBufferProperties\n"; - } + Timer timer("vkGetPhysicalDeviceExternalBufferProperties"); instance_dispatch_table(physicalDevice)->GetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties); } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceExternalFenceProperties\n"; - } + Timer timer("vkGetPhysicalDeviceExternalFenceProperties"); instance_dispatch_table(physicalDevice)->GetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties); } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceExternalSemaphoreProperties\n"; - } + Timer timer("vkGetPhysicalDeviceExternalSemaphoreProperties"); instance_dispatch_table(physicalDevice)->GetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceToolProperties\n"; - } + Timer timer("vkGetPhysicalDeviceToolProperties"); VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceToolProperties(physicalDevice, pToolCount, pToolProperties); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroySurfaceKHR\n"; - } + Timer timer("vkDestroySurfaceKHR"); instance_dispatch_table(instance)->DestroySurfaceKHR(instance, surface, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceSurfaceSupportKHR\n"; - } + Timer timer("vkGetPhysicalDeviceSurfaceSupportKHR"); VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceSurfaceCapabilitiesKHR\n"; - } + Timer timer("vkGetPhysicalDeviceSurfaceCapabilitiesKHR"); VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceSurfaceFormatsKHR\n"; - } + Timer timer("vkGetPhysicalDeviceSurfaceFormatsKHR"); VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceSurfacePresentModesKHR\n"; - } + Timer timer("vkGetPhysicalDeviceSurfacePresentModesKHR"); VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDevicePresentRectanglesKHR\n"; - } + Timer timer("vkGetPhysicalDevicePresentRectanglesKHR"); VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceDisplayPropertiesKHR\n"; - } + Timer timer("vkGetPhysicalDeviceDisplayPropertiesKHR"); VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, pPropertyCount, pProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceDisplayPlanePropertiesKHR\n"; - } + Timer timer("vkGetPhysicalDeviceDisplayPlanePropertiesKHR"); VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, pPropertyCount, pProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDisplayPlaneSupportedDisplaysKHR\n"; - } + Timer timer("vkGetDisplayPlaneSupportedDisplaysKHR"); VkResult result = instance_dispatch_table(physicalDevice)->GetDisplayPlaneSupportedDisplaysKHR(physicalDevice, planeIndex, pDisplayCount, pDisplays); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDisplayModePropertiesKHR\n"; - } + Timer timer("vkGetDisplayModePropertiesKHR"); VkResult result = instance_dispatch_table(physicalDevice)->GetDisplayModePropertiesKHR(physicalDevice, display, pPropertyCount, pProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateDisplayModeKHR\n"; - } + Timer timer("vkCreateDisplayModeKHR"); VkResult result = instance_dispatch_table(physicalDevice)->CreateDisplayModeKHR(physicalDevice, display, pCreateInfo, pAllocator, pMode); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDisplayPlaneCapabilitiesKHR\n"; - } + Timer timer("vkGetDisplayPlaneCapabilitiesKHR"); VkResult result = instance_dispatch_table(physicalDevice)->GetDisplayPlaneCapabilitiesKHR(physicalDevice, mode, planeIndex, pCapabilities); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateDisplayPlaneSurfaceKHR\n"; - } + Timer timer("vkCreateDisplayPlaneSurfaceKHR"); VkResult result = instance_dispatch_table(instance)->CreateDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); return result; } #if defined(VK_USE_PLATFORM_XLIB_KHR) template VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateXlibSurfaceKHR\n"; - } + Timer timer("vkCreateXlibSurfaceKHR"); VkResult result = instance_dispatch_table(instance)->CreateXlibSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); return result; } template VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceXlibPresentationSupportKHR\n"; - } + Timer timer("vkGetPhysicalDeviceXlibPresentationSupportKHR"); VkBool32 result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceXlibPresentationSupportKHR(physicalDevice, queueFamilyIndex, dpy, visualID); return result; } @@ -345,19 +238,13 @@ VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR(VkP #if defined(VK_USE_PLATFORM_XCB_KHR) template VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateXcbSurfaceKHR\n"; - } + Timer timer("vkCreateXcbSurfaceKHR"); VkResult result = instance_dispatch_table(instance)->CreateXcbSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); return result; } template VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceXcbPresentationSupportKHR\n"; - } + Timer timer("vkGetPhysicalDeviceXcbPresentationSupportKHR"); VkBool32 result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceXcbPresentationSupportKHR(physicalDevice, queueFamilyIndex, connection, visual_id); return result; } @@ -365,19 +252,13 @@ VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR(VkPh #if defined(VK_USE_PLATFORM_WAYLAND_KHR) template VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateWaylandSurfaceKHR\n"; - } + Timer timer("vkCreateWaylandSurfaceKHR"); VkResult result = instance_dispatch_table(instance)->CreateWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); return result; } template VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceWaylandPresentationSupportKHR\n"; - } + Timer timer("vkGetPhysicalDeviceWaylandPresentationSupportKHR"); VkBool32 result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceWaylandPresentationSupportKHR(physicalDevice, queueFamilyIndex, display); return result; } @@ -385,10 +266,7 @@ VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR( #if defined(VK_USE_PLATFORM_ANDROID_KHR) template VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateAndroidSurfaceKHR\n"; - } + Timer timer("vkCreateAndroidSurfaceKHR"); VkResult result = instance_dispatch_table(instance)->CreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); return result; } @@ -396,339 +274,225 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR(VkInstance instance, co #if defined(VK_USE_PLATFORM_WIN32_KHR) template VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateWin32SurfaceKHR\n"; - } + Timer timer("vkCreateWin32SurfaceKHR"); VkResult result = instance_dispatch_table(instance)->CreateWin32SurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); return result; } template VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceWin32PresentationSupportKHR\n"; - } + Timer timer("vkGetPhysicalDeviceWin32PresentationSupportKHR"); VkBool32 result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice, queueFamilyIndex); return result; } #endif // VK_USE_PLATFORM_WIN32_KHR template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoCapabilitiesKHR(VkPhysicalDevice physicalDevice, const VkVideoProfileInfoKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceVideoCapabilitiesKHR\n"; - } + Timer timer("vkGetPhysicalDeviceVideoCapabilitiesKHR"); VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceVideoCapabilitiesKHR(physicalDevice, pVideoProfile, pCapabilities); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoFormatPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceVideoFormatPropertiesKHR\n"; - } + Timer timer("vkGetPhysicalDeviceVideoFormatPropertiesKHR"); VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceVideoFormatPropertiesKHR(physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties); return result; } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceFeatures2KHR\n"; - } + Timer timer("vkGetPhysicalDeviceFeatures2KHR"); instance_dispatch_table(physicalDevice)->GetPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures); } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceProperties2KHR\n"; - } + Timer timer("vkGetPhysicalDeviceProperties2KHR"); instance_dispatch_table(physicalDevice)->GetPhysicalDeviceProperties2KHR(physicalDevice, pProperties); } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceFormatProperties2KHR\n"; - } + Timer timer("vkGetPhysicalDeviceFormatProperties2KHR"); instance_dispatch_table(physicalDevice)->GetPhysicalDeviceFormatProperties2KHR(physicalDevice, format, pFormatProperties); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceImageFormatProperties2KHR\n"; - } + Timer timer("vkGetPhysicalDeviceImageFormatProperties2KHR"); VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceImageFormatProperties2KHR(physicalDevice, pImageFormatInfo, pImageFormatProperties); return result; } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceQueueFamilyProperties2KHR\n"; - } + Timer timer("vkGetPhysicalDeviceQueueFamilyProperties2KHR"); instance_dispatch_table(physicalDevice)->GetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceMemoryProperties2KHR\n"; - } + Timer timer("vkGetPhysicalDeviceMemoryProperties2KHR"); instance_dispatch_table(physicalDevice)->GetPhysicalDeviceMemoryProperties2KHR(physicalDevice, pMemoryProperties); } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceSparseImageFormatProperties2KHR\n"; - } + Timer timer("vkGetPhysicalDeviceSparseImageFormatProperties2KHR"); instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice, pFormatInfo, pPropertyCount, pProperties); } template VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroupsKHR(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkEnumeratePhysicalDeviceGroupsKHR\n"; - } + Timer timer("vkEnumeratePhysicalDeviceGroupsKHR"); VkResult result = instance_dispatch_table(instance)->EnumeratePhysicalDeviceGroupsKHR(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); return result; } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceExternalBufferPropertiesKHR\n"; - } + Timer timer("vkGetPhysicalDeviceExternalBufferPropertiesKHR"); instance_dispatch_table(physicalDevice)->GetPhysicalDeviceExternalBufferPropertiesKHR(physicalDevice, pExternalBufferInfo, pExternalBufferProperties); } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR\n"; - } + Timer timer("vkGetPhysicalDeviceExternalSemaphorePropertiesKHR"); instance_dispatch_table(physicalDevice)->GetPhysicalDeviceExternalSemaphorePropertiesKHR(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceExternalFencePropertiesKHR\n"; - } + Timer timer("vkGetPhysicalDeviceExternalFencePropertiesKHR"); instance_dispatch_table(physicalDevice)->GetPhysicalDeviceExternalFencePropertiesKHR(physicalDevice, pExternalFenceInfo, pExternalFenceProperties); } template VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR\n"; - } + Timer timer("vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR"); VkResult result = instance_dispatch_table(physicalDevice)->EnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions); return result; } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR\n"; - } + Timer timer("vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR"); instance_dispatch_table(physicalDevice)->GetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(physicalDevice, pPerformanceQueryCreateInfo, pNumPasses); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceSurfaceCapabilities2KHR\n"; - } + Timer timer("vkGetPhysicalDeviceSurfaceCapabilities2KHR"); VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice, pSurfaceInfo, pSurfaceCapabilities); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceSurfaceFormats2KHR\n"; - } + Timer timer("vkGetPhysicalDeviceSurfaceFormats2KHR"); VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfaceFormats2KHR(physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceDisplayProperties2KHR\n"; - } + Timer timer("vkGetPhysicalDeviceDisplayProperties2KHR"); VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceDisplayProperties2KHR(physicalDevice, pPropertyCount, pProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceDisplayPlaneProperties2KHR\n"; - } + Timer timer("vkGetPhysicalDeviceDisplayPlaneProperties2KHR"); VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceDisplayPlaneProperties2KHR(physicalDevice, pPropertyCount, pProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDisplayModeProperties2KHR\n"; - } + Timer timer("vkGetDisplayModeProperties2KHR"); VkResult result = instance_dispatch_table(physicalDevice)->GetDisplayModeProperties2KHR(physicalDevice, display, pPropertyCount, pProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDisplayPlaneCapabilities2KHR\n"; - } + Timer timer("vkGetDisplayPlaneCapabilities2KHR"); VkResult result = instance_dispatch_table(physicalDevice)->GetDisplayPlaneCapabilities2KHR(physicalDevice, pDisplayPlaneInfo, pCapabilities); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceFragmentShadingRatesKHR\n"; - } + Timer timer("vkGetPhysicalDeviceFragmentShadingRatesKHR"); VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceFragmentShadingRatesKHR(physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR\n"; - } + Timer timer("vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR"); VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(physicalDevice, pQualityLevelInfo, pQualityLevelProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesKHR* pProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR\n"; - } + Timer timer("vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR"); VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceCooperativeMatrixPropertiesKHR(physicalDevice, pPropertyCount, pProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainKHR* pTimeDomains) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceCalibrateableTimeDomainsKHR\n"; - } + Timer timer("vkGetPhysicalDeviceCalibrateableTimeDomainsKHR"); VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceCalibrateableTimeDomainsKHR(physicalDevice, pTimeDomainCount, pTimeDomains); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateDebugReportCallbackEXT\n"; - } + Timer timer("vkCreateDebugReportCallbackEXT"); VkResult result = instance_dispatch_table(instance)->CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyDebugReportCallbackEXT\n"; - } + Timer timer("vkDestroyDebugReportCallbackEXT"); instance_dispatch_table(instance)->DestroyDebugReportCallbackEXT(instance, callback, pAllocator); } template VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDebugReportMessageEXT\n"; - } + Timer timer("vkDebugReportMessageEXT"); instance_dispatch_table(instance)->DebugReportMessageEXT(instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage); } #if defined(VK_USE_PLATFORM_GGP) template VKAPI_ATTR VkResult VKAPI_CALL vkCreateStreamDescriptorSurfaceGGP(VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateStreamDescriptorSurfaceGGP\n"; - } + Timer timer("vkCreateStreamDescriptorSurfaceGGP"); VkResult result = instance_dispatch_table(instance)->CreateStreamDescriptorSurfaceGGP(instance, pCreateInfo, pAllocator, pSurface); return result; } #endif // VK_USE_PLATFORM_GGP template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceExternalImageFormatPropertiesNV(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceExternalImageFormatPropertiesNV\n"; - } + Timer timer("vkGetPhysicalDeviceExternalImageFormatPropertiesNV"); VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceExternalImageFormatPropertiesNV(physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties); return result; } #if defined(VK_USE_PLATFORM_VI_NN) template VKAPI_ATTR VkResult VKAPI_CALL vkCreateViSurfaceNN(VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateViSurfaceNN\n"; - } + Timer timer("vkCreateViSurfaceNN"); VkResult result = instance_dispatch_table(instance)->CreateViSurfaceNN(instance, pCreateInfo, pAllocator, pSurface); return result; } #endif // VK_USE_PLATFORM_VI_NN template VKAPI_ATTR VkResult VKAPI_CALL vkReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkReleaseDisplayEXT\n"; - } + Timer timer("vkReleaseDisplayEXT"); VkResult result = instance_dispatch_table(physicalDevice)->ReleaseDisplayEXT(physicalDevice, display); return result; } #if defined(VK_USE_PLATFORM_XLIB_XRANDR_EXT) template VKAPI_ATTR VkResult VKAPI_CALL vkAcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkAcquireXlibDisplayEXT\n"; - } + Timer timer("vkAcquireXlibDisplayEXT"); VkResult result = instance_dispatch_table(physicalDevice)->AcquireXlibDisplayEXT(physicalDevice, dpy, display); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetRandROutputDisplayEXT\n"; - } + Timer timer("vkGetRandROutputDisplayEXT"); VkResult result = instance_dispatch_table(physicalDevice)->GetRandROutputDisplayEXT(physicalDevice, dpy, rrOutput, pDisplay); return result; } #endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceSurfaceCapabilities2EXT\n"; - } + Timer timer("vkGetPhysicalDeviceSurfaceCapabilities2EXT"); VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice, surface, pSurfaceCapabilities); return result; } #if defined(VK_USE_PLATFORM_IOS_MVK) template VKAPI_ATTR VkResult VKAPI_CALL vkCreateIOSSurfaceMVK(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateIOSSurfaceMVK\n"; - } + Timer timer("vkCreateIOSSurfaceMVK"); VkResult result = instance_dispatch_table(instance)->CreateIOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface); return result; } @@ -736,72 +500,48 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateIOSSurfaceMVK(VkInstance instance, const #if defined(VK_USE_PLATFORM_MACOS_MVK) template VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateMacOSSurfaceMVK\n"; - } + Timer timer("vkCreateMacOSSurfaceMVK"); VkResult result = instance_dispatch_table(instance)->CreateMacOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface); return result; } #endif // VK_USE_PLATFORM_MACOS_MVK template VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateDebugUtilsMessengerEXT\n"; - } + Timer timer("vkCreateDebugUtilsMessengerEXT"); VkResult result = instance_dispatch_table(instance)->CreateDebugUtilsMessengerEXT(instance, pCreateInfo, pAllocator, pMessenger); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyDebugUtilsMessengerEXT\n"; - } + Timer timer("vkDestroyDebugUtilsMessengerEXT"); instance_dispatch_table(instance)->DestroyDebugUtilsMessengerEXT(instance, messenger, pAllocator); } template VKAPI_ATTR void VKAPI_CALL vkSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkSubmitDebugUtilsMessageEXT\n"; - } + Timer timer("vkSubmitDebugUtilsMessageEXT"); instance_dispatch_table(instance)->SubmitDebugUtilsMessageEXT(instance, messageSeverity, messageTypes, pCallbackData); } template VKAPI_ATTR VkDeviceSize VKAPI_CALL vkGetPhysicalDeviceDescriptorSizeEXT(VkPhysicalDevice physicalDevice, VkDescriptorType descriptorType) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceDescriptorSizeEXT\n"; - } + Timer timer("vkGetPhysicalDeviceDescriptorSizeEXT"); VkDeviceSize result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceDescriptorSizeEXT(physicalDevice, descriptorType); return result; } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceMultisamplePropertiesEXT\n"; - } + Timer timer("vkGetPhysicalDeviceMultisamplePropertiesEXT"); instance_dispatch_table(physicalDevice)->GetPhysicalDeviceMultisamplePropertiesEXT(physicalDevice, samples, pMultisampleProperties); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainKHR* pTimeDomains) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT\n"; - } + Timer timer("vkGetPhysicalDeviceCalibrateableTimeDomainsEXT"); VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceCalibrateableTimeDomainsEXT(physicalDevice, pTimeDomainCount, pTimeDomains); return result; } #if defined(VK_USE_PLATFORM_FUCHSIA) template VKAPI_ATTR VkResult VKAPI_CALL vkCreateImagePipeSurfaceFUCHSIA(VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateImagePipeSurfaceFUCHSIA\n"; - } + Timer timer("vkCreateImagePipeSurfaceFUCHSIA"); VkResult result = instance_dispatch_table(instance)->CreateImagePipeSurfaceFUCHSIA(instance, pCreateInfo, pAllocator, pSurface); return result; } @@ -809,20 +549,14 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateImagePipeSurfaceFUCHSIA(VkInstance instan #if defined(VK_USE_PLATFORM_METAL_EXT) template VKAPI_ATTR VkResult VKAPI_CALL vkCreateMetalSurfaceEXT(VkInstance instance, const VkMetalSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateMetalSurfaceEXT\n"; - } + Timer timer("vkCreateMetalSurfaceEXT"); VkResult result = instance_dispatch_table(instance)->CreateMetalSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface); return result; } #endif // VK_USE_PLATFORM_METAL_EXT template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceToolPropertiesEXT(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceToolPropertiesEXT\n"; - } + Timer timer("vkGetPhysicalDeviceToolPropertiesEXT"); static const VkPhysicalDeviceToolPropertiesEXT api_dump_layer_tool_props = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT, @@ -849,76 +583,52 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceToolPropertiesEXT(VkPhysicalDe } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV\n"; - } + Timer timer("vkGetPhysicalDeviceCooperativeMatrixPropertiesNV"); VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceCooperativeMatrixPropertiesNV(physicalDevice, pPropertyCount, pProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV\n"; - } + Timer timer("vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV"); VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(physicalDevice, pCombinationCount, pCombinations); return result; } #if defined(VK_USE_PLATFORM_WIN32_KHR) template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModes2EXT(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceSurfacePresentModes2EXT\n"; - } + Timer timer("vkGetPhysicalDeviceSurfacePresentModes2EXT"); VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfacePresentModes2EXT(physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes); return result; } #endif // VK_USE_PLATFORM_WIN32_KHR template VKAPI_ATTR VkResult VKAPI_CALL vkCreateHeadlessSurfaceEXT(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateHeadlessSurfaceEXT\n"; - } + Timer timer("vkCreateHeadlessSurfaceEXT"); VkResult result = instance_dispatch_table(instance)->CreateHeadlessSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkAcquireDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkAcquireDrmDisplayEXT\n"; - } + Timer timer("vkAcquireDrmDisplayEXT"); VkResult result = instance_dispatch_table(physicalDevice)->AcquireDrmDisplayEXT(physicalDevice, drmFd, display); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR* display) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDrmDisplayEXT\n"; - } + Timer timer("vkGetDrmDisplayEXT"); VkResult result = instance_dispatch_table(physicalDevice)->GetDrmDisplayEXT(physicalDevice, drmFd, connectorId, display); return result; } #if defined(VK_USE_PLATFORM_WIN32_KHR) template VKAPI_ATTR VkResult VKAPI_CALL vkAcquireWinrtDisplayNV(VkPhysicalDevice physicalDevice, VkDisplayKHR display) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkAcquireWinrtDisplayNV\n"; - } + Timer timer("vkAcquireWinrtDisplayNV"); VkResult result = instance_dispatch_table(physicalDevice)->AcquireWinrtDisplayNV(physicalDevice, display); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetWinrtDisplayNV(VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR* pDisplay) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetWinrtDisplayNV\n"; - } + Timer timer("vkGetWinrtDisplayNV"); VkResult result = instance_dispatch_table(physicalDevice)->GetWinrtDisplayNV(physicalDevice, deviceRelativeId, pDisplay); return result; } @@ -926,19 +636,13 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetWinrtDisplayNV(VkPhysicalDevice physicalDevi #if defined(VK_USE_PLATFORM_DIRECTFB_EXT) template VKAPI_ATTR VkResult VKAPI_CALL vkCreateDirectFBSurfaceEXT(VkInstance instance, const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateDirectFBSurfaceEXT\n"; - } + Timer timer("vkCreateDirectFBSurfaceEXT"); VkResult result = instance_dispatch_table(instance)->CreateDirectFBSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface); return result; } template VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceDirectFBPresentationSupportEXT(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, IDirectFB* dfb) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceDirectFBPresentationSupportEXT\n"; - } + Timer timer("vkGetPhysicalDeviceDirectFBPresentationSupportEXT"); VkBool32 result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceDirectFBPresentationSupportEXT(physicalDevice, queueFamilyIndex, dfb); return result; } @@ -946,92 +650,62 @@ VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceDirectFBPresentationSupportEXT #if defined(VK_USE_PLATFORM_SCREEN_QNX) template VKAPI_ATTR VkResult VKAPI_CALL vkCreateScreenSurfaceQNX(VkInstance instance, const VkScreenSurfaceCreateInfoQNX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateScreenSurfaceQNX\n"; - } + Timer timer("vkCreateScreenSurfaceQNX"); VkResult result = instance_dispatch_table(instance)->CreateScreenSurfaceQNX(instance, pCreateInfo, pAllocator, pSurface); return result; } template VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceScreenPresentationSupportQNX(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct _screen_window* window) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceScreenPresentationSupportQNX\n"; - } + Timer timer("vkGetPhysicalDeviceScreenPresentationSupportQNX"); VkBool32 result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceScreenPresentationSupportQNX(physicalDevice, queueFamilyIndex, window); return result; } #endif // VK_USE_PLATFORM_SCREEN_QNX template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalTensorPropertiesARM(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalTensorInfoARM* pExternalTensorInfo, VkExternalTensorPropertiesARM* pExternalTensorProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceExternalTensorPropertiesARM\n"; - } + Timer timer("vkGetPhysicalDeviceExternalTensorPropertiesARM"); instance_dispatch_table(physicalDevice)->GetPhysicalDeviceExternalTensorPropertiesARM(physicalDevice, pExternalTensorInfo, pExternalTensorProperties); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceOpticalFlowImageFormatsNV(VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, uint32_t* pFormatCount, VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceOpticalFlowImageFormatsNV\n"; - } + Timer timer("vkGetPhysicalDeviceOpticalFlowImageFormatsNV"); VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceOpticalFlowImageFormatsNV(physicalDevice, pOpticalFlowImageFormatInfo, pFormatCount, pImageFormatProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeVectorPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeVectorPropertiesNV* pProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceCooperativeVectorPropertiesNV\n"; - } + Timer timer("vkGetPhysicalDeviceCooperativeVectorPropertiesNV"); VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceCooperativeVectorPropertiesNV(physicalDevice, pPropertyCount, pProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pQueueFamilyDataGraphPropertyCount, VkQueueFamilyDataGraphPropertiesARM* pQueueFamilyDataGraphProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM\n"; - } + Timer timer("vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM"); VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceQueueFamilyDataGraphPropertiesARM(physicalDevice, queueFamilyIndex, pQueueFamilyDataGraphPropertyCount, pQueueFamilyDataGraphProperties); return result; } template VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM* pQueueFamilyDataGraphProcessingEngineInfo, VkQueueFamilyDataGraphProcessingEnginePropertiesARM* pQueueFamilyDataGraphProcessingEngineProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM\n"; - } + Timer timer("vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM"); instance_dispatch_table(physicalDevice)->GetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM(physicalDevice, pQueueFamilyDataGraphProcessingEngineInfo, pQueueFamilyDataGraphProcessingEngineProperties); } #if defined(VK_USE_PLATFORM_OHOS) template VKAPI_ATTR VkResult VKAPI_CALL vkCreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateSurfaceOHOS\n"; - } + Timer timer("vkCreateSurfaceOHOS"); VkResult result = instance_dispatch_table(instance)->CreateSurfaceOHOS(instance, pCreateInfo, pAllocator, pSurface); return result; } #endif // VK_USE_PLATFORM_OHOS template VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixFlexibleDimensionsPropertiesNV* pProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV\n"; - } + Timer timer("vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV"); VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(physicalDevice, pPropertyCount, pProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterARM* pCounters, VkPerformanceCounterDescriptionARM* pCounterDescriptions) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM\n"; - } + Timer timer("vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM"); VkResult result = instance_dispatch_table(physicalDevice)->EnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM(physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions); return result; } @@ -1040,373 +714,221 @@ VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceQueueFamilyPerformanceCo template VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyDevice\n"; - } + Timer timer("vkDestroyDevice"); device_dispatch_table(device)->DestroyDevice(device, pAllocator); destroy_device_dispatch_table(get_dispatch_key(device)); } template VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDeviceQueue\n"; - } + Timer timer("vkGetDeviceQueue"); device_dispatch_table(device)->GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue); } template VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkQueueSubmit\n"; - } + Timer timer("vkQueueSubmit"); VkResult result = device_dispatch_table(queue)->QueueSubmit(queue, submitCount, pSubmits, fence); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle(VkQueue queue) { + Timer timer("vkQueueWaitIdle"); VkResult result = device_dispatch_table(queue)->QueueWaitIdle(queue); - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkQueueWaitIdle\n"; - } return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(VkDevice device) { + Timer timer("vkDeviceWaitIdle"); VkResult result = device_dispatch_table(device)->DeviceWaitIdle(device); - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDeviceWaitIdle\n"; - } return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkAllocateMemory\n"; - } + Timer timer("vkAllocateMemory"); VkResult result = device_dispatch_table(device)->AllocateMemory(device, pAllocateInfo, pAllocator, pMemory); return result; } template VKAPI_ATTR void VKAPI_CALL vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkFreeMemory\n"; - } + Timer timer("vkFreeMemory"); device_dispatch_table(device)->FreeMemory(device, memory, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkMapMemory\n"; - } + Timer timer("vkMapMemory"); VkResult result = device_dispatch_table(device)->MapMemory(device, memory, offset, size, flags, ppData); return result; } template VKAPI_ATTR void VKAPI_CALL vkUnmapMemory(VkDevice device, VkDeviceMemory memory) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkUnmapMemory\n"; - } + Timer timer("vkUnmapMemory"); device_dispatch_table(device)->UnmapMemory(device, memory); } template VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkFlushMappedMemoryRanges\n"; - } + Timer timer("vkFlushMappedMemoryRanges"); VkResult result = device_dispatch_table(device)->FlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkInvalidateMappedMemoryRanges\n"; - } + Timer timer("vkInvalidateMappedMemoryRanges"); VkResult result = device_dispatch_table(device)->InvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); return result; } template VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDeviceMemoryCommitment\n"; - } + Timer timer("vkGetDeviceMemoryCommitment"); device_dispatch_table(device)->GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes); } template VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkBindBufferMemory\n"; - } + Timer timer("vkBindBufferMemory"); VkResult result = device_dispatch_table(device)->BindBufferMemory(device, buffer, memory, memoryOffset); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkBindImageMemory\n"; - } + Timer timer("vkBindImageMemory"); VkResult result = device_dispatch_table(device)->BindImageMemory(device, image, memory, memoryOffset); return result; } template VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetBufferMemoryRequirements\n"; - } + Timer timer("vkGetBufferMemoryRequirements"); device_dispatch_table(device)->GetBufferMemoryRequirements(device, buffer, pMemoryRequirements); } template VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetImageMemoryRequirements\n"; - } + Timer timer("vkGetImageMemoryRequirements"); device_dispatch_table(device)->GetImageMemoryRequirements(device, image, pMemoryRequirements); } template VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetImageSparseMemoryRequirements\n"; - } + Timer timer("vkGetImageSparseMemoryRequirements"); device_dispatch_table(device)->GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements); } template VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkQueueBindSparse\n"; - } + Timer timer("vkQueueBindSparse"); VkResult result = device_dispatch_table(queue)->QueueBindSparse(queue, bindInfoCount, pBindInfo, fence); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateFence\n"; - } + Timer timer("vkCreateFence"); VkResult result = device_dispatch_table(device)->CreateFence(device, pCreateInfo, pAllocator, pFence); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyFence\n"; - } + Timer timer("vkDestroyFence"); device_dispatch_table(device)->DestroyFence(device, fence, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkResetFences\n"; - } + Timer timer("vkResetFences"); VkResult result = device_dispatch_table(device)->ResetFences(device, fenceCount, pFences); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus(VkDevice device, VkFence fence) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetFenceStatus\n"; - } + Timer timer("vkGetFenceStatus"); VkResult result = device_dispatch_table(device)->GetFenceStatus(device, fence); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) { + Timer timer("vkWaitForFences"); VkResult result = device_dispatch_table(device)->WaitForFences(device, fenceCount, pFences, waitAll, timeout); - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkWaitForFences\n"; - } return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateSemaphore\n"; - } + Timer timer("vkCreateSemaphore"); VkResult result = device_dispatch_table(device)->CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroySemaphore\n"; - } + Timer timer("vkDestroySemaphore"); device_dispatch_table(device)->DestroySemaphore(device, semaphore, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateQueryPool\n"; - } + Timer timer("vkCreateQueryPool"); VkResult result = device_dispatch_table(device)->CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyQueryPool\n"; - } + Timer timer("vkDestroyQueryPool"); device_dispatch_table(device)->DestroyQueryPool(device, queryPool, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) { + Timer timer("vkGetQueryPoolResults"); VkResult result = device_dispatch_table(device)->GetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags); - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetQueryPoolResults\n"; - } return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateBuffer\n"; - } + Timer timer("vkCreateBuffer"); VkResult result = device_dispatch_table(device)->CreateBuffer(device, pCreateInfo, pAllocator, pBuffer); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyBuffer\n"; - } + Timer timer("vkDestroyBuffer"); device_dispatch_table(device)->DestroyBuffer(device, buffer, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateImage\n"; - } + Timer timer("vkCreateImage"); VkResult result = device_dispatch_table(device)->CreateImage(device, pCreateInfo, pAllocator, pImage); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyImage\n"; - } + Timer timer("vkDestroyImage"); device_dispatch_table(device)->DestroyImage(device, image, pAllocator); } template VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetImageSubresourceLayout\n"; - } + Timer timer("vkGetImageSubresourceLayout"); device_dispatch_table(device)->GetImageSubresourceLayout(device, image, pSubresource, pLayout); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateImageView\n"; - } + Timer timer("vkCreateImageView"); VkResult result = device_dispatch_table(device)->CreateImageView(device, pCreateInfo, pAllocator, pView); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyImageView\n"; - } + Timer timer("vkDestroyImageView"); device_dispatch_table(device)->DestroyImageView(device, imageView, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateCommandPool\n"; - } + Timer timer("vkCreateCommandPool"); VkResult result = device_dispatch_table(device)->CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyCommandPool\n"; - } + Timer timer("vkDestroyCommandPool"); device_dispatch_table(device)->DestroyCommandPool(device, commandPool, pAllocator); ApiDumpInstance::current().eraseCmdBufferPool(device, commandPool); } template VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkResetCommandPool\n"; - } + Timer timer("vkResetCommandPool"); VkResult result = device_dispatch_table(device)->ResetCommandPool(device, commandPool, flags); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkAllocateCommandBuffers\n"; - } + Timer timer("vkAllocateCommandBuffers"); VkResult result = device_dispatch_table(device)->AllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers); if (result == VK_SUCCESS) ApiDumpInstance::current().addCmdBuffers( @@ -1418,3118 +940,1792 @@ VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers(VkDevice device, const V } template VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkFreeCommandBuffers\n"; - } + Timer timer("vkFreeCommandBuffers"); device_dispatch_table(device)->FreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers); ApiDumpInstance::current().eraseCmdBuffers(device, commandPool, std::vector(pCommandBuffers, pCommandBuffers + commandBufferCount)); } template VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkBeginCommandBuffer\n"; - } + Timer timer("vkBeginCommandBuffer"); VkResult result = device_dispatch_table(commandBuffer)->BeginCommandBuffer(commandBuffer, pBeginInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer(VkCommandBuffer commandBuffer) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkEndCommandBuffer\n"; - } + Timer timer("vkEndCommandBuffer"); VkResult result = device_dispatch_table(commandBuffer)->EndCommandBuffer(commandBuffer); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkResetCommandBuffer\n"; - } + Timer timer("vkResetCommandBuffer"); VkResult result = device_dispatch_table(commandBuffer)->ResetCommandBuffer(commandBuffer, flags); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdCopyBuffer\n"; - } + Timer timer("vkCmdCopyBuffer"); device_dispatch_table(commandBuffer)->CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdCopyImage\n"; - } + Timer timer("vkCmdCopyImage"); device_dispatch_table(commandBuffer)->CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdCopyBufferToImage\n"; - } + Timer timer("vkCmdCopyBufferToImage"); device_dispatch_table(commandBuffer)->CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions); } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdCopyImageToBuffer\n"; - } + Timer timer("vkCmdCopyImageToBuffer"); device_dispatch_table(commandBuffer)->CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions); } template VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdUpdateBuffer\n"; - } + Timer timer("vkCmdUpdateBuffer"); device_dispatch_table(commandBuffer)->CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData); } template VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdFillBuffer\n"; - } + Timer timer("vkCmdFillBuffer"); device_dispatch_table(commandBuffer)->CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data); } template VKAPI_ATTR void VKAPI_CALL 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) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdPipelineBarrier\n"; - } + Timer timer("vkCmdPipelineBarrier"); device_dispatch_table(commandBuffer)->CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); } template VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBeginQuery\n"; - } + Timer timer("vkCmdBeginQuery"); device_dispatch_table(commandBuffer)->CmdBeginQuery(commandBuffer, queryPool, query, flags); } template VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdEndQuery\n"; - } + Timer timer("vkCmdEndQuery"); device_dispatch_table(commandBuffer)->CmdEndQuery(commandBuffer, queryPool, query); } template VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdResetQueryPool\n"; - } + Timer timer("vkCmdResetQueryPool"); device_dispatch_table(commandBuffer)->CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount); } template VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdWriteTimestamp\n"; - } + Timer timer("vkCmdWriteTimestamp"); device_dispatch_table(commandBuffer)->CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query); } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdCopyQueryPoolResults\n"; - } + Timer timer("vkCmdCopyQueryPoolResults"); device_dispatch_table(commandBuffer)->CmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags); } template VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdExecuteCommands\n"; - } + Timer timer("vkCmdExecuteCommands"); device_dispatch_table(commandBuffer)->CmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateEvent\n"; - } + Timer timer("vkCreateEvent"); VkResult result = device_dispatch_table(device)->CreateEvent(device, pCreateInfo, pAllocator, pEvent); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyEvent\n"; - } + Timer timer("vkDestroyEvent"); device_dispatch_table(device)->DestroyEvent(device, event, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus(VkDevice device, VkEvent event) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetEventStatus\n"; - } + Timer timer("vkGetEventStatus"); VkResult result = device_dispatch_table(device)->GetEventStatus(device, event); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent(VkDevice device, VkEvent event) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkSetEvent\n"; - } + Timer timer("vkSetEvent"); VkResult result = device_dispatch_table(device)->SetEvent(device, event); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent(VkDevice device, VkEvent event) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkResetEvent\n"; - } + Timer timer("vkResetEvent"); VkResult result = device_dispatch_table(device)->ResetEvent(device, event); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateBufferView\n"; - } + Timer timer("vkCreateBufferView"); VkResult result = device_dispatch_table(device)->CreateBufferView(device, pCreateInfo, pAllocator, pView); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyBufferView\n"; - } + Timer timer("vkDestroyBufferView"); device_dispatch_table(device)->DestroyBufferView(device, bufferView, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateShaderModule\n"; - } + Timer timer("vkCreateShaderModule"); VkResult result = device_dispatch_table(device)->CreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyShaderModule\n"; - } + Timer timer("vkDestroyShaderModule"); device_dispatch_table(device)->DestroyShaderModule(device, shaderModule, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreatePipelineCache\n"; - } + Timer timer("vkCreatePipelineCache"); VkResult result = device_dispatch_table(device)->CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyPipelineCache\n"; - } + Timer timer("vkDestroyPipelineCache"); device_dispatch_table(device)->DestroyPipelineCache(device, pipelineCache, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPipelineCacheData\n"; - } + Timer timer("vkGetPipelineCacheData"); VkResult result = device_dispatch_table(device)->GetPipelineCacheData(device, pipelineCache, pDataSize, pData); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkMergePipelineCaches\n"; - } + Timer timer("vkMergePipelineCaches"); VkResult result = device_dispatch_table(device)->MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateComputePipelines\n"; - } + Timer timer("vkCreateComputePipelines"); VkResult result = device_dispatch_table(device)->CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyPipeline\n"; - } + Timer timer("vkDestroyPipeline"); device_dispatch_table(device)->DestroyPipeline(device, pipeline, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreatePipelineLayout\n"; - } + Timer timer("vkCreatePipelineLayout"); VkResult result = device_dispatch_table(device)->CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyPipelineLayout\n"; - } + Timer timer("vkDestroyPipelineLayout"); device_dispatch_table(device)->DestroyPipelineLayout(device, pipelineLayout, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateSampler\n"; - } + Timer timer("vkCreateSampler"); VkResult result = device_dispatch_table(device)->CreateSampler(device, pCreateInfo, pAllocator, pSampler); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroySampler\n"; - } + Timer timer("vkDestroySampler"); device_dispatch_table(device)->DestroySampler(device, sampler, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateDescriptorSetLayout\n"; - } + Timer timer("vkCreateDescriptorSetLayout"); VkResult result = device_dispatch_table(device)->CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyDescriptorSetLayout\n"; - } + Timer timer("vkDestroyDescriptorSetLayout"); device_dispatch_table(device)->DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateDescriptorPool\n"; - } + Timer timer("vkCreateDescriptorPool"); VkResult result = device_dispatch_table(device)->CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyDescriptorPool\n"; - } + Timer timer("vkDestroyDescriptorPool"); device_dispatch_table(device)->DestroyDescriptorPool(device, descriptorPool, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkResetDescriptorPool\n"; - } + Timer timer("vkResetDescriptorPool"); VkResult result = device_dispatch_table(device)->ResetDescriptorPool(device, descriptorPool, flags); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkAllocateDescriptorSets\n"; - } + Timer timer("vkAllocateDescriptorSets"); VkResult result = device_dispatch_table(device)->AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkFreeDescriptorSets\n"; - } + Timer timer("vkFreeDescriptorSets"); VkResult result = device_dispatch_table(device)->FreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets); return result; } template VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkUpdateDescriptorSets\n"; - } + Timer timer("vkUpdateDescriptorSets"); device_dispatch_table(device)->UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); } template VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBindPipeline\n"; - } + Timer timer("vkCmdBindPipeline"); device_dispatch_table(commandBuffer)->CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline); } template VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBindDescriptorSets\n"; - } + Timer timer("vkCmdBindDescriptorSets"); device_dispatch_table(commandBuffer)->CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); } template VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdClearColorImage\n"; - } + Timer timer("vkCmdClearColorImage"); device_dispatch_table(commandBuffer)->CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges); } template VKAPI_ATTR void VKAPI_CALL vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdDispatch\n"; - } + Timer timer("vkCmdDispatch"); device_dispatch_table(commandBuffer)->CmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ); } template VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdDispatchIndirect\n"; - } + Timer timer("vkCmdDispatchIndirect"); device_dispatch_table(commandBuffer)->CmdDispatchIndirect(commandBuffer, buffer, offset); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetEvent\n"; - } + Timer timer("vkCmdSetEvent"); device_dispatch_table(commandBuffer)->CmdSetEvent(commandBuffer, event, stageMask); } template VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdResetEvent\n"; - } + Timer timer("vkCmdResetEvent"); device_dispatch_table(commandBuffer)->CmdResetEvent(commandBuffer, event, stageMask); } template VKAPI_ATTR void VKAPI_CALL 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) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdWaitEvents\n"; - } + Timer timer("vkCmdWaitEvents"); device_dispatch_table(commandBuffer)->CmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); } template VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdPushConstants\n"; - } + Timer timer("vkCmdPushConstants"); device_dispatch_table(commandBuffer)->CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateGraphicsPipelines\n"; - } + Timer timer("vkCreateGraphicsPipelines"); VkResult result = device_dispatch_table(device)->CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateFramebuffer\n"; - } + Timer timer("vkCreateFramebuffer"); VkResult result = device_dispatch_table(device)->CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyFramebuffer\n"; - } + Timer timer("vkDestroyFramebuffer"); device_dispatch_table(device)->DestroyFramebuffer(device, framebuffer, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateRenderPass\n"; - } + Timer timer("vkCreateRenderPass"); VkResult result = device_dispatch_table(device)->CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyRenderPass\n"; - } + Timer timer("vkDestroyRenderPass"); device_dispatch_table(device)->DestroyRenderPass(device, renderPass, pAllocator); } template VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetRenderAreaGranularity\n"; - } + Timer timer("vkGetRenderAreaGranularity"); device_dispatch_table(device)->GetRenderAreaGranularity(device, renderPass, pGranularity); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetViewport\n"; - } + Timer timer("vkCmdSetViewport"); device_dispatch_table(commandBuffer)->CmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetScissor\n"; - } + Timer timer("vkCmdSetScissor"); device_dispatch_table(commandBuffer)->CmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetLineWidth\n"; - } + Timer timer("vkCmdSetLineWidth"); device_dispatch_table(commandBuffer)->CmdSetLineWidth(commandBuffer, lineWidth); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetDepthBias\n"; - } + Timer timer("vkCmdSetDepthBias"); device_dispatch_table(commandBuffer)->CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetBlendConstants\n"; - } + Timer timer("vkCmdSetBlendConstants"); device_dispatch_table(commandBuffer)->CmdSetBlendConstants(commandBuffer, blendConstants); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetDepthBounds\n"; - } + Timer timer("vkCmdSetDepthBounds"); device_dispatch_table(commandBuffer)->CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetStencilCompareMask\n"; - } + Timer timer("vkCmdSetStencilCompareMask"); device_dispatch_table(commandBuffer)->CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetStencilWriteMask\n"; - } + Timer timer("vkCmdSetStencilWriteMask"); device_dispatch_table(commandBuffer)->CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetStencilReference\n"; - } + Timer timer("vkCmdSetStencilReference"); device_dispatch_table(commandBuffer)->CmdSetStencilReference(commandBuffer, faceMask, reference); } template VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBindIndexBuffer\n"; - } + Timer timer("vkCmdBindIndexBuffer"); device_dispatch_table(commandBuffer)->CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType); } template VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBindVertexBuffers\n"; - } + Timer timer("vkCmdBindVertexBuffers"); device_dispatch_table(commandBuffer)->CmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets); } template VKAPI_ATTR void VKAPI_CALL vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdDraw\n"; - } + Timer timer("vkCmdDraw"); device_dispatch_table(commandBuffer)->CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); } template VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdDrawIndexed\n"; - } + Timer timer("vkCmdDrawIndexed"); device_dispatch_table(commandBuffer)->CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); } template VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdDrawIndirect\n"; - } + Timer timer("vkCmdDrawIndirect"); device_dispatch_table(commandBuffer)->CmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride); } template VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdDrawIndexedIndirect\n"; - } + Timer timer("vkCmdDrawIndexedIndirect"); device_dispatch_table(commandBuffer)->CmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride); } template VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBlitImage\n"; - } + Timer timer("vkCmdBlitImage"); device_dispatch_table(commandBuffer)->CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter); } template VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdClearDepthStencilImage\n"; - } + Timer timer("vkCmdClearDepthStencilImage"); device_dispatch_table(commandBuffer)->CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges); } template VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdClearAttachments\n"; - } + Timer timer("vkCmdClearAttachments"); device_dispatch_table(commandBuffer)->CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects); } template VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdResolveImage\n"; - } + Timer timer("vkCmdResolveImage"); device_dispatch_table(commandBuffer)->CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); } template VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBeginRenderPass\n"; - } + Timer timer("vkCmdBeginRenderPass"); device_dispatch_table(commandBuffer)->CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents); } template VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdNextSubpass\n"; - } + Timer timer("vkCmdNextSubpass"); device_dispatch_table(commandBuffer)->CmdNextSubpass(commandBuffer, contents); } template VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass(VkCommandBuffer commandBuffer) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdEndRenderPass\n"; - } + Timer timer("vkCmdEndRenderPass"); device_dispatch_table(commandBuffer)->CmdEndRenderPass(commandBuffer); } template VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkBindBufferMemory2\n"; - } + Timer timer("vkBindBufferMemory2"); VkResult result = device_dispatch_table(device)->BindBufferMemory2(device, bindInfoCount, pBindInfos); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkBindImageMemory2\n"; - } + Timer timer("vkBindImageMemory2"); VkResult result = device_dispatch_table(device)->BindImageMemory2(device, bindInfoCount, pBindInfos); return result; } template VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDeviceGroupPeerMemoryFeatures\n"; - } + Timer timer("vkGetDeviceGroupPeerMemoryFeatures"); device_dispatch_table(device)->GetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetDeviceMask\n"; - } + Timer timer("vkCmdSetDeviceMask"); device_dispatch_table(commandBuffer)->CmdSetDeviceMask(commandBuffer, deviceMask); } template VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetImageMemoryRequirements2\n"; - } + Timer timer("vkGetImageMemoryRequirements2"); device_dispatch_table(device)->GetImageMemoryRequirements2(device, pInfo, pMemoryRequirements); } template VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetBufferMemoryRequirements2\n"; - } + Timer timer("vkGetBufferMemoryRequirements2"); device_dispatch_table(device)->GetBufferMemoryRequirements2(device, pInfo, pMemoryRequirements); } template VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetImageSparseMemoryRequirements2\n"; - } + Timer timer("vkGetImageSparseMemoryRequirements2"); device_dispatch_table(device)->GetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); } template VKAPI_ATTR void VKAPI_CALL vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkTrimCommandPool\n"; - } + Timer timer("vkTrimCommandPool"); device_dispatch_table(device)->TrimCommandPool(device, commandPool, flags); } template VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDeviceQueue2\n"; - } + Timer timer("vkGetDeviceQueue2"); device_dispatch_table(device)->GetDeviceQueue2(device, pQueueInfo, pQueue); } template VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdDispatchBase\n"; - } + Timer timer("vkCmdDispatchBase"); device_dispatch_table(commandBuffer)->CmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateDescriptorUpdateTemplate\n"; - } + Timer timer("vkCreateDescriptorUpdateTemplate"); VkResult result = device_dispatch_table(device)->CreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyDescriptorUpdateTemplate\n"; - } + Timer timer("vkDestroyDescriptorUpdateTemplate"); device_dispatch_table(device)->DestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator); } template VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkUpdateDescriptorSetWithTemplate\n"; - } + Timer timer("vkUpdateDescriptorSetWithTemplate"); device_dispatch_table(device)->UpdateDescriptorSetWithTemplate(device, descriptorSet, descriptorUpdateTemplate, pData); } template VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDescriptorSetLayoutSupport\n"; - } + Timer timer("vkGetDescriptorSetLayoutSupport"); device_dispatch_table(device)->GetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateSamplerYcbcrConversion\n"; - } + Timer timer("vkCreateSamplerYcbcrConversion"); VkResult result = device_dispatch_table(device)->CreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroySamplerYcbcrConversion\n"; - } + Timer timer("vkDestroySamplerYcbcrConversion"); device_dispatch_table(device)->DestroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator); } template VKAPI_ATTR void VKAPI_CALL vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkResetQueryPool\n"; - } + Timer timer("vkResetQueryPool"); device_dispatch_table(device)->ResetQueryPool(device, queryPool, firstQuery, queryCount); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t* pValue) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetSemaphoreCounterValue\n"; - } + Timer timer("vkGetSemaphoreCounterValue"); VkResult result = device_dispatch_table(device)->GetSemaphoreCounterValue(device, semaphore, pValue); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout) { + Timer timer("vkWaitSemaphores"); VkResult result = device_dispatch_table(device)->WaitSemaphores(device, pWaitInfo, timeout); - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkWaitSemaphores\n"; - } return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkSignalSemaphore\n"; - } + Timer timer("vkSignalSemaphore"); VkResult result = device_dispatch_table(device)->SignalSemaphore(device, pSignalInfo); return result; } template VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetBufferDeviceAddress\n"; - } + Timer timer("vkGetBufferDeviceAddress"); VkDeviceAddress result = device_dispatch_table(device)->GetBufferDeviceAddress(device, pInfo); return result; } template VKAPI_ATTR uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetBufferOpaqueCaptureAddress\n"; - } + Timer timer("vkGetBufferOpaqueCaptureAddress"); uint64_t result = device_dispatch_table(device)->GetBufferOpaqueCaptureAddress(device, pInfo); return result; } template VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDeviceMemoryOpaqueCaptureAddress\n"; - } + Timer timer("vkGetDeviceMemoryOpaqueCaptureAddress"); uint64_t result = device_dispatch_table(device)->GetDeviceMemoryOpaqueCaptureAddress(device, pInfo); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdDrawIndirectCount\n"; - } + Timer timer("vkCmdDrawIndirectCount"); device_dispatch_table(commandBuffer)->CmdDrawIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); } template VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdDrawIndexedIndirectCount\n"; - } + Timer timer("vkCmdDrawIndexedIndirectCount"); device_dispatch_table(commandBuffer)->CmdDrawIndexedIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateRenderPass2\n"; - } + Timer timer("vkCreateRenderPass2"); VkResult result = device_dispatch_table(device)->CreateRenderPass2(device, pCreateInfo, pAllocator, pRenderPass); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBeginRenderPass2\n"; - } + Timer timer("vkCmdBeginRenderPass2"); device_dispatch_table(commandBuffer)->CmdBeginRenderPass2(commandBuffer, pRenderPassBegin, pSubpassBeginInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass2(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdNextSubpass2\n"; - } + Timer timer("vkCmdNextSubpass2"); device_dispatch_table(commandBuffer)->CmdNextSubpass2(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdEndRenderPass2\n"; - } + Timer timer("vkCmdEndRenderPass2"); device_dispatch_table(commandBuffer)->CmdEndRenderPass2(commandBuffer, pSubpassEndInfo); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreatePrivateDataSlot(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreatePrivateDataSlot\n"; - } + Timer timer("vkCreatePrivateDataSlot"); VkResult result = device_dispatch_table(device)->CreatePrivateDataSlot(device, pCreateInfo, pAllocator, pPrivateDataSlot); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyPrivateDataSlot\n"; - } + Timer timer("vkDestroyPrivateDataSlot"); device_dispatch_table(device)->DestroyPrivateDataSlot(device, privateDataSlot, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkSetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkSetPrivateData\n"; - } + Timer timer("vkSetPrivateData"); VkResult result = device_dispatch_table(device)->SetPrivateData(device, objectType, objectHandle, privateDataSlot, data); return result; } template VKAPI_ATTR void VKAPI_CALL vkGetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPrivateData\n"; - } + Timer timer("vkGetPrivateData"); device_dispatch_table(device)->GetPrivateData(device, objectType, objectHandle, privateDataSlot, pData); } template VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdPipelineBarrier2\n"; - } + Timer timer("vkCmdPipelineBarrier2"); device_dispatch_table(commandBuffer)->CmdPipelineBarrier2(commandBuffer, pDependencyInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdWriteTimestamp2\n"; - } + Timer timer("vkCmdWriteTimestamp2"); device_dispatch_table(commandBuffer)->CmdWriteTimestamp2(commandBuffer, stage, queryPool, query); } template VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkQueueSubmit2\n"; - } + Timer timer("vkQueueSubmit2"); VkResult result = device_dispatch_table(queue)->QueueSubmit2(queue, submitCount, pSubmits, fence); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer2(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdCopyBuffer2\n"; - } + Timer timer("vkCmdCopyBuffer2"); device_dispatch_table(commandBuffer)->CmdCopyBuffer2(commandBuffer, pCopyBufferInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage2(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdCopyImage2\n"; - } + Timer timer("vkCmdCopyImage2"); device_dispatch_table(commandBuffer)->CmdCopyImage2(commandBuffer, pCopyImageInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage2(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdCopyBufferToImage2\n"; - } + Timer timer("vkCmdCopyBufferToImage2"); device_dispatch_table(commandBuffer)->CmdCopyBufferToImage2(commandBuffer, pCopyBufferToImageInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer2(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdCopyImageToBuffer2\n"; - } + Timer timer("vkCmdCopyImageToBuffer2"); device_dispatch_table(commandBuffer)->CmdCopyImageToBuffer2(commandBuffer, pCopyImageToBufferInfo); } template VKAPI_ATTR void VKAPI_CALL vkGetDeviceBufferMemoryRequirements(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDeviceBufferMemoryRequirements\n"; - } + Timer timer("vkGetDeviceBufferMemoryRequirements"); device_dispatch_table(device)->GetDeviceBufferMemoryRequirements(device, pInfo, pMemoryRequirements); } template VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDeviceImageMemoryRequirements\n"; - } + Timer timer("vkGetDeviceImageMemoryRequirements"); device_dispatch_table(device)->GetDeviceImageMemoryRequirements(device, pInfo, pMemoryRequirements); } template VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSparseMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDeviceImageSparseMemoryRequirements\n"; - } + Timer timer("vkGetDeviceImageSparseMemoryRequirements"); device_dispatch_table(device)->GetDeviceImageSparseMemoryRequirements(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetEvent2\n"; - } + Timer timer("vkCmdSetEvent2"); device_dispatch_table(commandBuffer)->CmdSetEvent2(commandBuffer, event, pDependencyInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdResetEvent2\n"; - } + Timer timer("vkCmdResetEvent2"); device_dispatch_table(commandBuffer)->CmdResetEvent2(commandBuffer, event, stageMask); } template VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdWaitEvents2\n"; - } + Timer timer("vkCmdWaitEvents2"); device_dispatch_table(commandBuffer)->CmdWaitEvents2(commandBuffer, eventCount, pEvents, pDependencyInfos); } template VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage2(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBlitImage2\n"; - } + Timer timer("vkCmdBlitImage2"); device_dispatch_table(commandBuffer)->CmdBlitImage2(commandBuffer, pBlitImageInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage2(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdResolveImage2\n"; - } + Timer timer("vkCmdResolveImage2"); device_dispatch_table(commandBuffer)->CmdResolveImage2(commandBuffer, pResolveImageInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBeginRendering\n"; - } + Timer timer("vkCmdBeginRendering"); device_dispatch_table(commandBuffer)->CmdBeginRendering(commandBuffer, pRenderingInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdEndRendering(VkCommandBuffer commandBuffer) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdEndRendering\n"; - } + Timer timer("vkCmdEndRendering"); device_dispatch_table(commandBuffer)->CmdEndRendering(commandBuffer); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetCullMode\n"; - } + Timer timer("vkCmdSetCullMode"); device_dispatch_table(commandBuffer)->CmdSetCullMode(commandBuffer, cullMode); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetFrontFace\n"; - } + Timer timer("vkCmdSetFrontFace"); device_dispatch_table(commandBuffer)->CmdSetFrontFace(commandBuffer, frontFace); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveTopology(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetPrimitiveTopology\n"; - } + Timer timer("vkCmdSetPrimitiveTopology"); device_dispatch_table(commandBuffer)->CmdSetPrimitiveTopology(commandBuffer, primitiveTopology); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetViewportWithCount\n"; - } + Timer timer("vkCmdSetViewportWithCount"); device_dispatch_table(commandBuffer)->CmdSetViewportWithCount(commandBuffer, viewportCount, pViewports); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetScissorWithCount\n"; - } + Timer timer("vkCmdSetScissorWithCount"); device_dispatch_table(commandBuffer)->CmdSetScissorWithCount(commandBuffer, scissorCount, pScissors); } template VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBindVertexBuffers2\n"; - } + Timer timer("vkCmdBindVertexBuffers2"); device_dispatch_table(commandBuffer)->CmdBindVertexBuffers2(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetDepthTestEnable\n"; - } + Timer timer("vkCmdSetDepthTestEnable"); device_dispatch_table(commandBuffer)->CmdSetDepthTestEnable(commandBuffer, depthTestEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetDepthWriteEnable\n"; - } + Timer timer("vkCmdSetDepthWriteEnable"); device_dispatch_table(commandBuffer)->CmdSetDepthWriteEnable(commandBuffer, depthWriteEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetDepthCompareOp\n"; - } + Timer timer("vkCmdSetDepthCompareOp"); device_dispatch_table(commandBuffer)->CmdSetDepthCompareOp(commandBuffer, depthCompareOp); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetDepthBoundsTestEnable\n"; - } + Timer timer("vkCmdSetDepthBoundsTestEnable"); device_dispatch_table(commandBuffer)->CmdSetDepthBoundsTestEnable(commandBuffer, depthBoundsTestEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilTestEnable(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetStencilTestEnable\n"; - } + Timer timer("vkCmdSetStencilTestEnable"); device_dispatch_table(commandBuffer)->CmdSetStencilTestEnable(commandBuffer, stencilTestEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetStencilOp\n"; - } + Timer timer("vkCmdSetStencilOp"); device_dispatch_table(commandBuffer)->CmdSetStencilOp(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetRasterizerDiscardEnable\n"; - } + Timer timer("vkCmdSetRasterizerDiscardEnable"); device_dispatch_table(commandBuffer)->CmdSetRasterizerDiscardEnable(commandBuffer, rasterizerDiscardEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetDepthBiasEnable\n"; - } + Timer timer("vkCmdSetDepthBiasEnable"); device_dispatch_table(commandBuffer)->CmdSetDepthBiasEnable(commandBuffer, depthBiasEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetPrimitiveRestartEnable\n"; - } + Timer timer("vkCmdSetPrimitiveRestartEnable"); device_dispatch_table(commandBuffer)->CmdSetPrimitiveRestartEnable(commandBuffer, primitiveRestartEnable); } template VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory2(VkDevice device, const VkMemoryMapInfo* pMemoryMapInfo, void** ppData) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkMapMemory2\n"; - } + Timer timer("vkMapMemory2"); VkResult result = device_dispatch_table(device)->MapMemory2(device, pMemoryMapInfo, ppData); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkUnmapMemory2(VkDevice device, const VkMemoryUnmapInfo* pMemoryUnmapInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkUnmapMemory2\n"; - } + Timer timer("vkUnmapMemory2"); VkResult result = device_dispatch_table(device)->UnmapMemory2(device, pMemoryUnmapInfo); return result; } template VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSubresourceLayout(VkDevice device, const VkDeviceImageSubresourceInfo* pInfo, VkSubresourceLayout2* pLayout) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDeviceImageSubresourceLayout\n"; - } + Timer timer("vkGetDeviceImageSubresourceLayout"); device_dispatch_table(device)->GetDeviceImageSubresourceLayout(device, pInfo, pLayout); } template VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout2(VkDevice device, VkImage image, const VkImageSubresource2* pSubresource, VkSubresourceLayout2* pLayout) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetImageSubresourceLayout2\n"; - } + Timer timer("vkGetImageSubresourceLayout2"); device_dispatch_table(device)->GetImageSubresourceLayout2(device, image, pSubresource, pLayout); } template VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToImage(VkDevice device, const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCopyMemoryToImage\n"; - } + Timer timer("vkCopyMemoryToImage"); VkResult result = device_dispatch_table(device)->CopyMemoryToImage(device, pCopyMemoryToImageInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCopyImageToMemory(VkDevice device, const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCopyImageToMemory\n"; - } + Timer timer("vkCopyImageToMemory"); VkResult result = device_dispatch_table(device)->CopyImageToMemory(device, pCopyImageToMemoryInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCopyImageToImage(VkDevice device, const VkCopyImageToImageInfo* pCopyImageToImageInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCopyImageToImage\n"; - } + Timer timer("vkCopyImageToImage"); VkResult result = device_dispatch_table(device)->CopyImageToImage(device, pCopyImageToImageInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkTransitionImageLayout(VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfo* pTransitions) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkTransitionImageLayout\n"; - } + Timer timer("vkTransitionImageLayout"); VkResult result = device_dispatch_table(device)->TransitionImageLayout(device, transitionCount, pTransitions); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSet(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdPushDescriptorSet\n"; - } + Timer timer("vkCmdPushDescriptorSet"); device_dispatch_table(commandBuffer)->CmdPushDescriptorSet(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites); } template VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplate(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdPushDescriptorSetWithTemplate\n"; - } + Timer timer("vkCmdPushDescriptorSetWithTemplate"); device_dispatch_table(commandBuffer)->CmdPushDescriptorSetWithTemplate(commandBuffer, descriptorUpdateTemplate, layout, set, pData); } template VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets2(VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBindDescriptorSets2\n"; - } + Timer timer("vkCmdBindDescriptorSets2"); device_dispatch_table(commandBuffer)->CmdBindDescriptorSets2(commandBuffer, pBindDescriptorSetsInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants2(VkCommandBuffer commandBuffer, const VkPushConstantsInfo* pPushConstantsInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdPushConstants2\n"; - } + Timer timer("vkCmdPushConstants2"); device_dispatch_table(commandBuffer)->CmdPushConstants2(commandBuffer, pPushConstantsInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSet2(VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfo* pPushDescriptorSetInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdPushDescriptorSet2\n"; - } + Timer timer("vkCmdPushDescriptorSet2"); device_dispatch_table(commandBuffer)->CmdPushDescriptorSet2(commandBuffer, pPushDescriptorSetInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplate2(VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdPushDescriptorSetWithTemplate2\n"; - } + Timer timer("vkCmdPushDescriptorSetWithTemplate2"); device_dispatch_table(commandBuffer)->CmdPushDescriptorSetWithTemplate2(commandBuffer, pPushDescriptorSetWithTemplateInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStipple(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetLineStipple\n"; - } + Timer timer("vkCmdSetLineStipple"); device_dispatch_table(commandBuffer)->CmdSetLineStipple(commandBuffer, lineStippleFactor, lineStipplePattern); } template VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer2(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBindIndexBuffer2\n"; - } + Timer timer("vkCmdBindIndexBuffer2"); device_dispatch_table(commandBuffer)->CmdBindIndexBuffer2(commandBuffer, buffer, offset, size, indexType); } template VKAPI_ATTR void VKAPI_CALL vkGetRenderingAreaGranularity(VkDevice device, const VkRenderingAreaInfo* pRenderingAreaInfo, VkExtent2D* pGranularity) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetRenderingAreaGranularity\n"; - } + Timer timer("vkGetRenderingAreaGranularity"); device_dispatch_table(device)->GetRenderingAreaGranularity(device, pRenderingAreaInfo, pGranularity); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetRenderingAttachmentLocations(VkCommandBuffer commandBuffer, const VkRenderingAttachmentLocationInfo* pLocationInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetRenderingAttachmentLocations\n"; - } + Timer timer("vkCmdSetRenderingAttachmentLocations"); device_dispatch_table(commandBuffer)->CmdSetRenderingAttachmentLocations(commandBuffer, pLocationInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetRenderingInputAttachmentIndices(VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetRenderingInputAttachmentIndices\n"; - } + Timer timer("vkCmdSetRenderingInputAttachmentIndices"); device_dispatch_table(commandBuffer)->CmdSetRenderingInputAttachmentIndices(commandBuffer, pInputAttachmentIndexInfo); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateSwapchainKHR\n"; - } + Timer timer("vkCreateSwapchainKHR"); VkResult result = device_dispatch_table(device)->CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroySwapchainKHR\n"; - } + Timer timer("vkDestroySwapchainKHR"); device_dispatch_table(device)->DestroySwapchainKHR(device, swapchain, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetSwapchainImagesKHR\n"; - } + Timer timer("vkGetSwapchainImagesKHR"); VkResult result = device_dispatch_table(device)->GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) { + Timer timer("vkAcquireNextImageKHR"); VkResult result = device_dispatch_table(device)->AcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex); - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkAcquireNextImageKHR\n"; - } return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo) { + Timer timer("vkQueuePresentKHR"); VkResult result = device_dispatch_table(queue)->QueuePresentKHR(queue, pPresentInfo); - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkQueuePresentKHR\n"; - } ApiDumpInstance::current().nextFrame(); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDeviceGroupPresentCapabilitiesKHR\n"; - } + Timer timer("vkGetDeviceGroupPresentCapabilitiesKHR"); VkResult result = device_dispatch_table(device)->GetDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDeviceGroupSurfacePresentModesKHR\n"; - } + Timer timer("vkGetDeviceGroupSurfacePresentModesKHR"); VkResult result = device_dispatch_table(device)->GetDeviceGroupSurfacePresentModesKHR(device, surface, pModes); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkAcquireNextImage2KHR\n"; - } + Timer timer("vkAcquireNextImage2KHR"); VkResult result = device_dispatch_table(device)->AcquireNextImage2KHR(device, pAcquireInfo, pImageIndex); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateSharedSwapchainsKHR\n"; - } + Timer timer("vkCreateSharedSwapchainsKHR"); VkResult result = device_dispatch_table(device)->CreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateVideoSessionKHR(VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateVideoSessionKHR\n"; - } + Timer timer("vkCreateVideoSessionKHR"); VkResult result = device_dispatch_table(device)->CreateVideoSessionKHR(device, pCreateInfo, pAllocator, pVideoSession); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyVideoSessionKHR(VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyVideoSessionKHR\n"; - } + Timer timer("vkDestroyVideoSessionKHR"); device_dispatch_table(device)->DestroyVideoSessionKHR(device, videoSession, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetVideoSessionMemoryRequirementsKHR(VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetVideoSessionMemoryRequirementsKHR\n"; - } + Timer timer("vkGetVideoSessionMemoryRequirementsKHR"); VkResult result = device_dispatch_table(device)->GetVideoSessionMemoryRequirementsKHR(device, videoSession, pMemoryRequirementsCount, pMemoryRequirements); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkBindVideoSessionMemoryKHR(VkDevice device, VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkBindVideoSessionMemoryKHR\n"; - } + Timer timer("vkBindVideoSessionMemoryKHR"); VkResult result = device_dispatch_table(device)->BindVideoSessionMemoryKHR(device, videoSession, bindSessionMemoryInfoCount, pBindSessionMemoryInfos); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateVideoSessionParametersKHR(VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateVideoSessionParametersKHR\n"; - } + Timer timer("vkCreateVideoSessionParametersKHR"); VkResult result = device_dispatch_table(device)->CreateVideoSessionParametersKHR(device, pCreateInfo, pAllocator, pVideoSessionParameters); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkUpdateVideoSessionParametersKHR(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkUpdateVideoSessionParametersKHR\n"; - } + Timer timer("vkUpdateVideoSessionParametersKHR"); VkResult result = device_dispatch_table(device)->UpdateVideoSessionParametersKHR(device, videoSessionParameters, pUpdateInfo); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyVideoSessionParametersKHR(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyVideoSessionParametersKHR\n"; - } + Timer timer("vkDestroyVideoSessionParametersKHR"); device_dispatch_table(device)->DestroyVideoSessionParametersKHR(device, videoSessionParameters, pAllocator); } template VKAPI_ATTR void VKAPI_CALL vkCmdBeginVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR* pBeginInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBeginVideoCodingKHR\n"; - } + Timer timer("vkCmdBeginVideoCodingKHR"); device_dispatch_table(commandBuffer)->CmdBeginVideoCodingKHR(commandBuffer, pBeginInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdEndVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR* pEndCodingInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdEndVideoCodingKHR\n"; - } + Timer timer("vkCmdEndVideoCodingKHR"); device_dispatch_table(commandBuffer)->CmdEndVideoCodingKHR(commandBuffer, pEndCodingInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdControlVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdControlVideoCodingKHR\n"; - } + Timer timer("vkCmdControlVideoCodingKHR"); device_dispatch_table(commandBuffer)->CmdControlVideoCodingKHR(commandBuffer, pCodingControlInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdDecodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pDecodeInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdDecodeVideoKHR\n"; - } + Timer timer("vkCmdDecodeVideoKHR"); device_dispatch_table(commandBuffer)->CmdDecodeVideoKHR(commandBuffer, pDecodeInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderingKHR(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBeginRenderingKHR\n"; - } + Timer timer("vkCmdBeginRenderingKHR"); device_dispatch_table(commandBuffer)->CmdBeginRenderingKHR(commandBuffer, pRenderingInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderingKHR(VkCommandBuffer commandBuffer) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdEndRenderingKHR\n"; - } + Timer timer("vkCmdEndRenderingKHR"); device_dispatch_table(commandBuffer)->CmdEndRenderingKHR(commandBuffer); } template VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDeviceGroupPeerMemoryFeaturesKHR\n"; - } + Timer timer("vkGetDeviceGroupPeerMemoryFeaturesKHR"); device_dispatch_table(device)->GetDeviceGroupPeerMemoryFeaturesKHR(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetDeviceMaskKHR\n"; - } + Timer timer("vkCmdSetDeviceMaskKHR"); device_dispatch_table(commandBuffer)->CmdSetDeviceMaskKHR(commandBuffer, deviceMask); } template VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdDispatchBaseKHR\n"; - } + Timer timer("vkCmdDispatchBaseKHR"); device_dispatch_table(commandBuffer)->CmdDispatchBaseKHR(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); } template VKAPI_ATTR void VKAPI_CALL vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkTrimCommandPoolKHR\n"; - } + Timer timer("vkTrimCommandPoolKHR"); device_dispatch_table(device)->TrimCommandPoolKHR(device, commandPool, flags); } #if defined(VK_USE_PLATFORM_WIN32_KHR) template VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR(VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetMemoryWin32HandleKHR\n"; - } + Timer timer("vkGetMemoryWin32HandleKHR"); VkResult result = device_dispatch_table(device)->GetMemoryWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetMemoryWin32HandlePropertiesKHR\n"; - } + Timer timer("vkGetMemoryWin32HandlePropertiesKHR"); VkResult result = device_dispatch_table(device)->GetMemoryWin32HandlePropertiesKHR(device, handleType, handle, pMemoryWin32HandleProperties); return result; } #endif // VK_USE_PLATFORM_WIN32_KHR template VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdKHR(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetMemoryFdKHR\n"; - } + Timer timer("vkGetMemoryFdKHR"); VkResult result = device_dispatch_table(device)->GetMemoryFdKHR(device, pGetFdInfo, pFd); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetMemoryFdPropertiesKHR\n"; - } + Timer timer("vkGetMemoryFdPropertiesKHR"); VkResult result = device_dispatch_table(device)->GetMemoryFdPropertiesKHR(device, handleType, fd, pMemoryFdProperties); return result; } #if defined(VK_USE_PLATFORM_WIN32_KHR) template VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHR(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkImportSemaphoreWin32HandleKHR\n"; - } + Timer timer("vkImportSemaphoreWin32HandleKHR"); VkResult result = device_dispatch_table(device)->ImportSemaphoreWin32HandleKHR(device, pImportSemaphoreWin32HandleInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHR(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetSemaphoreWin32HandleKHR\n"; - } + Timer timer("vkGetSemaphoreWin32HandleKHR"); VkResult result = device_dispatch_table(device)->GetSemaphoreWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); return result; } #endif // VK_USE_PLATFORM_WIN32_KHR template VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreFdKHR(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkImportSemaphoreFdKHR\n"; - } + Timer timer("vkImportSemaphoreFdKHR"); VkResult result = device_dispatch_table(device)->ImportSemaphoreFdKHR(device, pImportSemaphoreFdInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetSemaphoreFdKHR\n"; - } + Timer timer("vkGetSemaphoreFdKHR"); VkResult result = device_dispatch_table(device)->GetSemaphoreFdKHR(device, pGetFdInfo, pFd); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdPushDescriptorSetKHR\n"; - } + Timer timer("vkCmdPushDescriptorSetKHR"); device_dispatch_table(commandBuffer)->CmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites); } template VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdPushDescriptorSetWithTemplateKHR\n"; - } + Timer timer("vkCmdPushDescriptorSetWithTemplateKHR"); device_dispatch_table(commandBuffer)->CmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplateKHR(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateDescriptorUpdateTemplateKHR\n"; - } + Timer timer("vkCreateDescriptorUpdateTemplateKHR"); VkResult result = device_dispatch_table(device)->CreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplateKHR(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyDescriptorUpdateTemplateKHR\n"; - } + Timer timer("vkDestroyDescriptorUpdateTemplateKHR"); device_dispatch_table(device)->DestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator); } template VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkUpdateDescriptorSetWithTemplateKHR\n"; - } + Timer timer("vkUpdateDescriptorSetWithTemplateKHR"); device_dispatch_table(device)->UpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate, pData); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateRenderPass2KHR\n"; - } + Timer timer("vkCreateRenderPass2KHR"); VkResult result = device_dispatch_table(device)->CreateRenderPass2KHR(device, pCreateInfo, pAllocator, pRenderPass); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBeginRenderPass2KHR\n"; - } + Timer timer("vkCmdBeginRenderPass2KHR"); device_dispatch_table(commandBuffer)->CmdBeginRenderPass2KHR(commandBuffer, pRenderPassBegin, pSubpassBeginInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdNextSubpass2KHR\n"; - } + Timer timer("vkCmdNextSubpass2KHR"); device_dispatch_table(commandBuffer)->CmdNextSubpass2KHR(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdEndRenderPass2KHR\n"; - } + Timer timer("vkCmdEndRenderPass2KHR"); device_dispatch_table(commandBuffer)->CmdEndRenderPass2KHR(commandBuffer, pSubpassEndInfo); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetSwapchainStatusKHR\n"; - } + Timer timer("vkGetSwapchainStatusKHR"); VkResult result = device_dispatch_table(device)->GetSwapchainStatusKHR(device, swapchain); return result; } #if defined(VK_USE_PLATFORM_WIN32_KHR) template VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceWin32HandleKHR(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkImportFenceWin32HandleKHR\n"; - } + Timer timer("vkImportFenceWin32HandleKHR"); VkResult result = device_dispatch_table(device)->ImportFenceWin32HandleKHR(device, pImportFenceWin32HandleInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetFenceWin32HandleKHR\n"; - } + Timer timer("vkGetFenceWin32HandleKHR"); VkResult result = device_dispatch_table(device)->GetFenceWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); return result; } #endif // VK_USE_PLATFORM_WIN32_KHR template VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceFdKHR(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkImportFenceFdKHR\n"; - } + Timer timer("vkImportFenceFdKHR"); VkResult result = device_dispatch_table(device)->ImportFenceFdKHR(device, pImportFenceFdInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetFenceFdKHR\n"; - } + Timer timer("vkGetFenceFdKHR"); VkResult result = device_dispatch_table(device)->GetFenceFdKHR(device, pGetFdInfo, pFd); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkAcquireProfilingLockKHR(VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkAcquireProfilingLockKHR\n"; - } + Timer timer("vkAcquireProfilingLockKHR"); VkResult result = device_dispatch_table(device)->AcquireProfilingLockKHR(device, pInfo); return result; } template VKAPI_ATTR void VKAPI_CALL vkReleaseProfilingLockKHR(VkDevice device) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkReleaseProfilingLockKHR\n"; - } + Timer timer("vkReleaseProfilingLockKHR"); device_dispatch_table(device)->ReleaseProfilingLockKHR(device); } template VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetImageMemoryRequirements2KHR\n"; - } + Timer timer("vkGetImageMemoryRequirements2KHR"); device_dispatch_table(device)->GetImageMemoryRequirements2KHR(device, pInfo, pMemoryRequirements); } template VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetBufferMemoryRequirements2KHR\n"; - } + Timer timer("vkGetBufferMemoryRequirements2KHR"); device_dispatch_table(device)->GetBufferMemoryRequirements2KHR(device, pInfo, pMemoryRequirements); } template VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2KHR(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetImageSparseMemoryRequirements2KHR\n"; - } + Timer timer("vkGetImageSparseMemoryRequirements2KHR"); device_dispatch_table(device)->GetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversionKHR(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateSamplerYcbcrConversionKHR\n"; - } + Timer timer("vkCreateSamplerYcbcrConversionKHR"); VkResult result = device_dispatch_table(device)->CreateSamplerYcbcrConversionKHR(device, pCreateInfo, pAllocator, pYcbcrConversion); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroySamplerYcbcrConversionKHR\n"; - } + Timer timer("vkDestroySamplerYcbcrConversionKHR"); device_dispatch_table(device)->DestroySamplerYcbcrConversionKHR(device, ycbcrConversion, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkBindBufferMemory2KHR\n"; - } + Timer timer("vkBindBufferMemory2KHR"); VkResult result = device_dispatch_table(device)->BindBufferMemory2KHR(device, bindInfoCount, pBindInfos); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkBindImageMemory2KHR\n"; - } + Timer timer("vkBindImageMemory2KHR"); VkResult result = device_dispatch_table(device)->BindImageMemory2KHR(device, bindInfoCount, pBindInfos); return result; } template VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupportKHR(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDescriptorSetLayoutSupportKHR\n"; - } + Timer timer("vkGetDescriptorSetLayoutSupportKHR"); device_dispatch_table(device)->GetDescriptorSetLayoutSupportKHR(device, pCreateInfo, pSupport); } template VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdDrawIndirectCountKHR\n"; - } + Timer timer("vkCmdDrawIndirectCountKHR"); device_dispatch_table(commandBuffer)->CmdDrawIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); } template VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdDrawIndexedIndirectCountKHR\n"; - } + Timer timer("vkCmdDrawIndexedIndirectCountKHR"); device_dispatch_table(commandBuffer)->CmdDrawIndexedIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore, uint64_t* pValue) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetSemaphoreCounterValueKHR\n"; - } + Timer timer("vkGetSemaphoreCounterValueKHR"); VkResult result = device_dispatch_table(device)->GetSemaphoreCounterValueKHR(device, semaphore, pValue); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkWaitSemaphoresKHR(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout) { + Timer timer("vkWaitSemaphoresKHR"); VkResult result = device_dispatch_table(device)->WaitSemaphoresKHR(device, pWaitInfo, timeout); - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkWaitSemaphoresKHR\n"; - } return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkSignalSemaphoreKHR(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkSignalSemaphoreKHR\n"; - } + Timer timer("vkSignalSemaphoreKHR"); VkResult result = device_dispatch_table(device)->SignalSemaphoreKHR(device, pSignalInfo); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetFragmentShadingRateKHR\n"; - } + Timer timer("vkCmdSetFragmentShadingRateKHR"); device_dispatch_table(commandBuffer)->CmdSetFragmentShadingRateKHR(commandBuffer, pFragmentSize, combinerOps); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetRenderingAttachmentLocationsKHR(VkCommandBuffer commandBuffer, const VkRenderingAttachmentLocationInfo* pLocationInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetRenderingAttachmentLocationsKHR\n"; - } + Timer timer("vkCmdSetRenderingAttachmentLocationsKHR"); device_dispatch_table(commandBuffer)->CmdSetRenderingAttachmentLocationsKHR(commandBuffer, pLocationInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetRenderingInputAttachmentIndicesKHR(VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetRenderingInputAttachmentIndicesKHR\n"; - } + Timer timer("vkCmdSetRenderingInputAttachmentIndicesKHR"); device_dispatch_table(commandBuffer)->CmdSetRenderingInputAttachmentIndicesKHR(commandBuffer, pInputAttachmentIndexInfo); } template VKAPI_ATTR VkResult VKAPI_CALL vkWaitForPresentKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkWaitForPresentKHR\n"; - } + Timer timer("vkWaitForPresentKHR"); VkResult result = device_dispatch_table(device)->WaitForPresentKHR(device, swapchain, presentId, timeout); return result; } template VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetBufferDeviceAddressKHR\n"; - } + Timer timer("vkGetBufferDeviceAddressKHR"); VkDeviceAddress result = device_dispatch_table(device)->GetBufferDeviceAddressKHR(device, pInfo); return result; } template VKAPI_ATTR uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetBufferOpaqueCaptureAddressKHR\n"; - } + Timer timer("vkGetBufferOpaqueCaptureAddressKHR"); uint64_t result = device_dispatch_table(device)->GetBufferOpaqueCaptureAddressKHR(device, pInfo); return result; } template VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddressKHR(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDeviceMemoryOpaqueCaptureAddressKHR\n"; - } + Timer timer("vkGetDeviceMemoryOpaqueCaptureAddressKHR"); uint64_t result = device_dispatch_table(device)->GetDeviceMemoryOpaqueCaptureAddressKHR(device, pInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateDeferredOperationKHR(VkDevice device, const VkAllocationCallbacks* pAllocator, VkDeferredOperationKHR* pDeferredOperation) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateDeferredOperationKHR\n"; - } + Timer timer("vkCreateDeferredOperationKHR"); VkResult result = device_dispatch_table(device)->CreateDeferredOperationKHR(device, pAllocator, pDeferredOperation); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyDeferredOperationKHR(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyDeferredOperationKHR\n"; - } + Timer timer("vkDestroyDeferredOperationKHR"); device_dispatch_table(device)->DestroyDeferredOperationKHR(device, operation, pAllocator); } template VKAPI_ATTR uint32_t VKAPI_CALL vkGetDeferredOperationMaxConcurrencyKHR(VkDevice device, VkDeferredOperationKHR operation) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDeferredOperationMaxConcurrencyKHR\n"; - } + Timer timer("vkGetDeferredOperationMaxConcurrencyKHR"); uint32_t result = device_dispatch_table(device)->GetDeferredOperationMaxConcurrencyKHR(device, operation); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetDeferredOperationResultKHR(VkDevice device, VkDeferredOperationKHR operation) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDeferredOperationResultKHR\n"; - } + Timer timer("vkGetDeferredOperationResultKHR"); VkResult result = device_dispatch_table(device)->GetDeferredOperationResultKHR(device, operation); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkDeferredOperationJoinKHR(VkDevice device, VkDeferredOperationKHR operation) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDeferredOperationJoinKHR\n"; - } + Timer timer("vkDeferredOperationJoinKHR"); VkResult result = device_dispatch_table(device)->DeferredOperationJoinKHR(device, operation); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutablePropertiesKHR(VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPipelineExecutablePropertiesKHR\n"; - } + Timer timer("vkGetPipelineExecutablePropertiesKHR"); VkResult result = device_dispatch_table(device)->GetPipelineExecutablePropertiesKHR(device, pPipelineInfo, pExecutableCount, pProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableStatisticsKHR(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPipelineExecutableStatisticsKHR\n"; - } + Timer timer("vkGetPipelineExecutableStatisticsKHR"); VkResult result = device_dispatch_table(device)->GetPipelineExecutableStatisticsKHR(device, pExecutableInfo, pStatisticCount, pStatistics); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableInternalRepresentationsKHR(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPipelineExecutableInternalRepresentationsKHR\n"; - } + Timer timer("vkGetPipelineExecutableInternalRepresentationsKHR"); VkResult result = device_dispatch_table(device)->GetPipelineExecutableInternalRepresentationsKHR(device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory2KHR(VkDevice device, const VkMemoryMapInfo* pMemoryMapInfo, void** ppData) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkMapMemory2KHR\n"; - } + Timer timer("vkMapMemory2KHR"); VkResult result = device_dispatch_table(device)->MapMemory2KHR(device, pMemoryMapInfo, ppData); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkUnmapMemory2KHR(VkDevice device, const VkMemoryUnmapInfo* pMemoryUnmapInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkUnmapMemory2KHR\n"; - } + Timer timer("vkUnmapMemory2KHR"); VkResult result = device_dispatch_table(device)->UnmapMemory2KHR(device, pMemoryUnmapInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetEncodedVideoSessionParametersKHR(VkDevice device, const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, size_t* pDataSize, void* pData) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetEncodedVideoSessionParametersKHR\n"; - } + Timer timer("vkGetEncodedVideoSessionParametersKHR"); VkResult result = device_dispatch_table(device)->GetEncodedVideoSessionParametersKHR(device, pVideoSessionParametersInfo, pFeedbackInfo, pDataSize, pData); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdEncodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdEncodeVideoKHR\n"; - } + Timer timer("vkCmdEncodeVideoKHR"); device_dispatch_table(commandBuffer)->CmdEncodeVideoKHR(commandBuffer, pEncodeInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetEvent2KHR\n"; - } + Timer timer("vkCmdSetEvent2KHR"); device_dispatch_table(commandBuffer)->CmdSetEvent2KHR(commandBuffer, event, pDependencyInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdResetEvent2KHR\n"; - } + Timer timer("vkCmdResetEvent2KHR"); device_dispatch_table(commandBuffer)->CmdResetEvent2KHR(commandBuffer, event, stageMask); } template VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdWaitEvents2KHR\n"; - } + Timer timer("vkCmdWaitEvents2KHR"); device_dispatch_table(commandBuffer)->CmdWaitEvents2KHR(commandBuffer, eventCount, pEvents, pDependencyInfos); } template VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdPipelineBarrier2KHR\n"; - } + Timer timer("vkCmdPipelineBarrier2KHR"); device_dispatch_table(commandBuffer)->CmdPipelineBarrier2KHR(commandBuffer, pDependencyInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdWriteTimestamp2KHR\n"; - } + Timer timer("vkCmdWriteTimestamp2KHR"); device_dispatch_table(commandBuffer)->CmdWriteTimestamp2KHR(commandBuffer, stage, queryPool, query); } template VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit2KHR(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkQueueSubmit2KHR\n"; - } + Timer timer("vkQueueSubmit2KHR"); VkResult result = device_dispatch_table(queue)->QueueSubmit2KHR(queue, submitCount, pSubmits, fence); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdCopyBuffer2KHR\n"; - } + Timer timer("vkCmdCopyBuffer2KHR"); device_dispatch_table(commandBuffer)->CmdCopyBuffer2KHR(commandBuffer, pCopyBufferInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdCopyImage2KHR\n"; - } + Timer timer("vkCmdCopyImage2KHR"); device_dispatch_table(commandBuffer)->CmdCopyImage2KHR(commandBuffer, pCopyImageInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdCopyBufferToImage2KHR\n"; - } + Timer timer("vkCmdCopyBufferToImage2KHR"); device_dispatch_table(commandBuffer)->CmdCopyBufferToImage2KHR(commandBuffer, pCopyBufferToImageInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdCopyImageToBuffer2KHR\n"; - } + Timer timer("vkCmdCopyImageToBuffer2KHR"); device_dispatch_table(commandBuffer)->CmdCopyImageToBuffer2KHR(commandBuffer, pCopyImageToBufferInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBlitImage2KHR\n"; - } + Timer timer("vkCmdBlitImage2KHR"); device_dispatch_table(commandBuffer)->CmdBlitImage2KHR(commandBuffer, pBlitImageInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdResolveImage2KHR\n"; - } + Timer timer("vkCmdResolveImage2KHR"); device_dispatch_table(commandBuffer)->CmdResolveImage2KHR(commandBuffer, pResolveImageInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysIndirect2KHR(VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdTraceRaysIndirect2KHR\n"; - } + Timer timer("vkCmdTraceRaysIndirect2KHR"); device_dispatch_table(commandBuffer)->CmdTraceRaysIndirect2KHR(commandBuffer, indirectDeviceAddress); } template VKAPI_ATTR void VKAPI_CALL vkGetDeviceBufferMemoryRequirementsKHR(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDeviceBufferMemoryRequirementsKHR\n"; - } + Timer timer("vkGetDeviceBufferMemoryRequirementsKHR"); device_dispatch_table(device)->GetDeviceBufferMemoryRequirementsKHR(device, pInfo, pMemoryRequirements); } template VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageMemoryRequirementsKHR(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDeviceImageMemoryRequirementsKHR\n"; - } + Timer timer("vkGetDeviceImageMemoryRequirementsKHR"); device_dispatch_table(device)->GetDeviceImageMemoryRequirementsKHR(device, pInfo, pMemoryRequirements); } template VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSparseMemoryRequirementsKHR(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDeviceImageSparseMemoryRequirementsKHR\n"; - } + Timer timer("vkGetDeviceImageSparseMemoryRequirementsKHR"); device_dispatch_table(device)->GetDeviceImageSparseMemoryRequirementsKHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); } template VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer2KHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBindIndexBuffer2KHR\n"; - } + Timer timer("vkCmdBindIndexBuffer2KHR"); device_dispatch_table(commandBuffer)->CmdBindIndexBuffer2KHR(commandBuffer, buffer, offset, size, indexType); } template VKAPI_ATTR void VKAPI_CALL vkGetRenderingAreaGranularityKHR(VkDevice device, const VkRenderingAreaInfo* pRenderingAreaInfo, VkExtent2D* pGranularity) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetRenderingAreaGranularityKHR\n"; - } + Timer timer("vkGetRenderingAreaGranularityKHR"); device_dispatch_table(device)->GetRenderingAreaGranularityKHR(device, pRenderingAreaInfo, pGranularity); } template VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSubresourceLayoutKHR(VkDevice device, const VkDeviceImageSubresourceInfo* pInfo, VkSubresourceLayout2* pLayout) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDeviceImageSubresourceLayoutKHR\n"; - } + Timer timer("vkGetDeviceImageSubresourceLayoutKHR"); device_dispatch_table(device)->GetDeviceImageSubresourceLayoutKHR(device, pInfo, pLayout); } template VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout2KHR(VkDevice device, VkImage image, const VkImageSubresource2* pSubresource, VkSubresourceLayout2* pLayout) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetImageSubresourceLayout2KHR\n"; - } + Timer timer("vkGetImageSubresourceLayout2KHR"); device_dispatch_table(device)->GetImageSubresourceLayout2KHR(device, image, pSubresource, pLayout); } template VKAPI_ATTR VkResult VKAPI_CALL vkWaitForPresent2KHR(VkDevice device, VkSwapchainKHR swapchain, const VkPresentWait2InfoKHR* pPresentWait2Info) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkWaitForPresent2KHR\n"; - } + Timer timer("vkWaitForPresent2KHR"); VkResult result = device_dispatch_table(device)->WaitForPresent2KHR(device, swapchain, pPresentWait2Info); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineBinariesKHR(VkDevice device, const VkPipelineBinaryCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineBinaryHandlesInfoKHR* pBinaries) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreatePipelineBinariesKHR\n"; - } + Timer timer("vkCreatePipelineBinariesKHR"); VkResult result = device_dispatch_table(device)->CreatePipelineBinariesKHR(device, pCreateInfo, pAllocator, pBinaries); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineBinaryKHR(VkDevice device, VkPipelineBinaryKHR pipelineBinary, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyPipelineBinaryKHR\n"; - } + Timer timer("vkDestroyPipelineBinaryKHR"); device_dispatch_table(device)->DestroyPipelineBinaryKHR(device, pipelineBinary, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineKeyKHR(VkDevice device, const VkPipelineCreateInfoKHR* pPipelineCreateInfo, VkPipelineBinaryKeyKHR* pPipelineKey) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPipelineKeyKHR\n"; - } + Timer timer("vkGetPipelineKeyKHR"); VkResult result = device_dispatch_table(device)->GetPipelineKeyKHR(device, pPipelineCreateInfo, pPipelineKey); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineBinaryDataKHR(VkDevice device, const VkPipelineBinaryDataInfoKHR* pInfo, VkPipelineBinaryKeyKHR* pPipelineBinaryKey, size_t* pPipelineBinaryDataSize, void* pPipelineBinaryData) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPipelineBinaryDataKHR\n"; - } + Timer timer("vkGetPipelineBinaryDataKHR"); VkResult result = device_dispatch_table(device)->GetPipelineBinaryDataKHR(device, pInfo, pPipelineBinaryKey, pPipelineBinaryDataSize, pPipelineBinaryData); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkReleaseCapturedPipelineDataKHR(VkDevice device, const VkReleaseCapturedPipelineDataInfoKHR* pInfo, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkReleaseCapturedPipelineDataKHR\n"; - } + Timer timer("vkReleaseCapturedPipelineDataKHR"); VkResult result = device_dispatch_table(device)->ReleaseCapturedPipelineDataKHR(device, pInfo, pAllocator); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkReleaseSwapchainImagesKHR(VkDevice device, const VkReleaseSwapchainImagesInfoKHR* pReleaseInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkReleaseSwapchainImagesKHR\n"; - } + Timer timer("vkReleaseSwapchainImagesKHR"); VkResult result = device_dispatch_table(device)->ReleaseSwapchainImagesKHR(device, pReleaseInfo); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleKHR(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetLineStippleKHR\n"; - } + Timer timer("vkCmdSetLineStippleKHR"); device_dispatch_table(commandBuffer)->CmdSetLineStippleKHR(commandBuffer, lineStippleFactor, lineStipplePattern); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetCalibratedTimestampsKHR(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetCalibratedTimestampsKHR\n"; - } + Timer timer("vkGetCalibratedTimestampsKHR"); VkResult result = device_dispatch_table(device)->GetCalibratedTimestampsKHR(device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets2KHR(VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBindDescriptorSets2KHR\n"; - } + Timer timer("vkCmdBindDescriptorSets2KHR"); device_dispatch_table(commandBuffer)->CmdBindDescriptorSets2KHR(commandBuffer, pBindDescriptorSetsInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants2KHR(VkCommandBuffer commandBuffer, const VkPushConstantsInfo* pPushConstantsInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdPushConstants2KHR\n"; - } + Timer timer("vkCmdPushConstants2KHR"); device_dispatch_table(commandBuffer)->CmdPushConstants2KHR(commandBuffer, pPushConstantsInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSet2KHR(VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfo* pPushDescriptorSetInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdPushDescriptorSet2KHR\n"; - } + Timer timer("vkCmdPushDescriptorSet2KHR"); device_dispatch_table(commandBuffer)->CmdPushDescriptorSet2KHR(commandBuffer, pPushDescriptorSetInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplate2KHR(VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdPushDescriptorSetWithTemplate2KHR\n"; - } + Timer timer("vkCmdPushDescriptorSetWithTemplate2KHR"); device_dispatch_table(commandBuffer)->CmdPushDescriptorSetWithTemplate2KHR(commandBuffer, pPushDescriptorSetWithTemplateInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDescriptorBufferOffsets2EXT(VkCommandBuffer commandBuffer, const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetDescriptorBufferOffsets2EXT\n"; - } + Timer timer("vkCmdSetDescriptorBufferOffsets2EXT"); device_dispatch_table(commandBuffer)->CmdSetDescriptorBufferOffsets2EXT(commandBuffer, pSetDescriptorBufferOffsetsInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT\n"; - } + Timer timer("vkCmdBindDescriptorBufferEmbeddedSamplers2EXT"); device_dispatch_table(commandBuffer)->CmdBindDescriptorBufferEmbeddedSamplers2EXT(commandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryIndirectKHR(VkCommandBuffer commandBuffer, const VkCopyMemoryIndirectInfoKHR* pCopyMemoryIndirectInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdCopyMemoryIndirectKHR\n"; - } + Timer timer("vkCmdCopyMemoryIndirectKHR"); device_dispatch_table(commandBuffer)->CmdCopyMemoryIndirectKHR(commandBuffer, pCopyMemoryIndirectInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToImageIndirectKHR(VkCommandBuffer commandBuffer, const VkCopyMemoryToImageIndirectInfoKHR* pCopyMemoryToImageIndirectInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdCopyMemoryToImageIndirectKHR\n"; - } + Timer timer("vkCmdCopyMemoryToImageIndirectKHR"); device_dispatch_table(commandBuffer)->CmdCopyMemoryToImageIndirectKHR(commandBuffer, pCopyMemoryToImageIndirectInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdEndRendering2KHR(VkCommandBuffer commandBuffer, const VkRenderingEndInfoKHR* pRenderingEndInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdEndRendering2KHR\n"; - } + Timer timer("vkCmdEndRendering2KHR"); device_dispatch_table(commandBuffer)->CmdEndRendering2KHR(commandBuffer, pRenderingEndInfo); } template VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDebugMarkerSetObjectTagEXT\n"; - } + Timer timer("vkDebugMarkerSetObjectTagEXT"); VkResult result = device_dispatch_table(device)->DebugMarkerSetObjectTagEXT(device, pTagInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - ApiDumpInstance::current().update_object_name_map(pNameInfo); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDebugMarkerSetObjectNameEXT\n"; - } + Timer timer("vkDebugMarkerSetObjectNameEXT"); VkResult result = device_dispatch_table(device)->DebugMarkerSetObjectNameEXT(device, pNameInfo); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdDebugMarkerBeginEXT\n"; - } + Timer timer("vkCmdDebugMarkerBeginEXT"); device_dispatch_table(commandBuffer)->CmdDebugMarkerBeginEXT(commandBuffer, pMarkerInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdDebugMarkerEndEXT\n"; - } + Timer timer("vkCmdDebugMarkerEndEXT"); device_dispatch_table(commandBuffer)->CmdDebugMarkerEndEXT(commandBuffer); } template VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdDebugMarkerInsertEXT\n"; - } + Timer timer("vkCmdDebugMarkerInsertEXT"); device_dispatch_table(commandBuffer)->CmdDebugMarkerInsertEXT(commandBuffer, pMarkerInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBindTransformFeedbackBuffersEXT\n"; - } + Timer timer("vkCmdBindTransformFeedbackBuffersEXT"); device_dispatch_table(commandBuffer)->CmdBindTransformFeedbackBuffersEXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes); } template VKAPI_ATTR void VKAPI_CALL vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBeginTransformFeedbackEXT\n"; - } + Timer timer("vkCmdBeginTransformFeedbackEXT"); device_dispatch_table(commandBuffer)->CmdBeginTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); } template VKAPI_ATTR void VKAPI_CALL vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdEndTransformFeedbackEXT\n"; - } + Timer timer("vkCmdEndTransformFeedbackEXT"); device_dispatch_table(commandBuffer)->CmdEndTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); } template VKAPI_ATTR void VKAPI_CALL vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBeginQueryIndexedEXT\n"; - } + Timer timer("vkCmdBeginQueryIndexedEXT"); device_dispatch_table(commandBuffer)->CmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index); } template VKAPI_ATTR void VKAPI_CALL vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdEndQueryIndexedEXT\n"; - } + Timer timer("vkCmdEndQueryIndexedEXT"); device_dispatch_table(commandBuffer)->CmdEndQueryIndexedEXT(commandBuffer, queryPool, query, index); } template VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdDrawIndirectByteCountEXT\n"; - } + Timer timer("vkCmdDrawIndirectByteCountEXT"); device_dispatch_table(commandBuffer)->CmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateCuModuleNVX(VkDevice device, const VkCuModuleCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuModuleNVX* pModule) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateCuModuleNVX\n"; - } + Timer timer("vkCreateCuModuleNVX"); VkResult result = device_dispatch_table(device)->CreateCuModuleNVX(device, pCreateInfo, pAllocator, pModule); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateCuFunctionNVX(VkDevice device, const VkCuFunctionCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuFunctionNVX* pFunction) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateCuFunctionNVX\n"; - } + Timer timer("vkCreateCuFunctionNVX"); VkResult result = device_dispatch_table(device)->CreateCuFunctionNVX(device, pCreateInfo, pAllocator, pFunction); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyCuModuleNVX(VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyCuModuleNVX\n"; - } + Timer timer("vkDestroyCuModuleNVX"); device_dispatch_table(device)->DestroyCuModuleNVX(device, module, pAllocator); } template VKAPI_ATTR void VKAPI_CALL vkDestroyCuFunctionNVX(VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyCuFunctionNVX\n"; - } + Timer timer("vkDestroyCuFunctionNVX"); device_dispatch_table(device)->DestroyCuFunctionNVX(device, function, pAllocator); } template VKAPI_ATTR void VKAPI_CALL vkCmdCuLaunchKernelNVX(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdCuLaunchKernelNVX\n"; - } + Timer timer("vkCmdCuLaunchKernelNVX"); device_dispatch_table(commandBuffer)->CmdCuLaunchKernelNVX(commandBuffer, pLaunchInfo); } template VKAPI_ATTR uint32_t VKAPI_CALL vkGetImageViewHandleNVX(VkDevice device, const VkImageViewHandleInfoNVX* pInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetImageViewHandleNVX\n"; - } + Timer timer("vkGetImageViewHandleNVX"); uint32_t result = device_dispatch_table(device)->GetImageViewHandleNVX(device, pInfo); return result; } template VKAPI_ATTR uint64_t VKAPI_CALL vkGetImageViewHandle64NVX(VkDevice device, const VkImageViewHandleInfoNVX* pInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetImageViewHandle64NVX\n"; - } + Timer timer("vkGetImageViewHandle64NVX"); uint64_t result = device_dispatch_table(device)->GetImageViewHandle64NVX(device, pInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetImageViewAddressNVX(VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX* pProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetImageViewAddressNVX\n"; - } + Timer timer("vkGetImageViewAddressNVX"); VkResult result = device_dispatch_table(device)->GetImageViewAddressNVX(device, imageView, pProperties); return result; } template VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceCombinedImageSamplerIndexNVX(VkDevice device, uint64_t imageViewIndex, uint64_t samplerIndex) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDeviceCombinedImageSamplerIndexNVX\n"; - } + Timer timer("vkGetDeviceCombinedImageSamplerIndexNVX"); uint64_t result = device_dispatch_table(device)->GetDeviceCombinedImageSamplerIndexNVX(device, imageViewIndex, samplerIndex); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdDrawIndirectCountAMD\n"; - } + Timer timer("vkCmdDrawIndirectCountAMD"); device_dispatch_table(commandBuffer)->CmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); } template VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdDrawIndexedIndirectCountAMD\n"; - } + Timer timer("vkCmdDrawIndexedIndirectCountAMD"); device_dispatch_table(commandBuffer)->CmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetShaderInfoAMD\n"; - } + Timer timer("vkGetShaderInfoAMD"); VkResult result = device_dispatch_table(device)->GetShaderInfoAMD(device, pipeline, shaderStage, infoType, pInfoSize, pInfo); return result; } #if defined(VK_USE_PLATFORM_WIN32_KHR) template VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetMemoryWin32HandleNV\n"; - } + Timer timer("vkGetMemoryWin32HandleNV"); VkResult result = device_dispatch_table(device)->GetMemoryWin32HandleNV(device, memory, handleType, pHandle); return result; } #endif // VK_USE_PLATFORM_WIN32_KHR template VKAPI_ATTR void VKAPI_CALL vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBeginConditionalRenderingEXT\n"; - } + Timer timer("vkCmdBeginConditionalRenderingEXT"); device_dispatch_table(commandBuffer)->CmdBeginConditionalRenderingEXT(commandBuffer, pConditionalRenderingBegin); } template VKAPI_ATTR void VKAPI_CALL vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdEndConditionalRenderingEXT\n"; - } + Timer timer("vkCmdEndConditionalRenderingEXT"); device_dispatch_table(commandBuffer)->CmdEndConditionalRenderingEXT(commandBuffer); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetViewportWScalingNV\n"; - } + Timer timer("vkCmdSetViewportWScalingNV"); device_dispatch_table(commandBuffer)->CmdSetViewportWScalingNV(commandBuffer, firstViewport, viewportCount, pViewportWScalings); } template VKAPI_ATTR VkResult VKAPI_CALL vkDisplayPowerControlEXT(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDisplayPowerControlEXT\n"; - } + Timer timer("vkDisplayPowerControlEXT"); VkResult result = device_dispatch_table(device)->DisplayPowerControlEXT(device, display, pDisplayPowerInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDeviceEventEXT(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkRegisterDeviceEventEXT\n"; - } + Timer timer("vkRegisterDeviceEventEXT"); VkResult result = device_dispatch_table(device)->RegisterDeviceEventEXT(device, pDeviceEventInfo, pAllocator, pFence); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDisplayEventEXT(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkRegisterDisplayEventEXT\n"; - } + Timer timer("vkRegisterDisplayEventEXT"); VkResult result = device_dispatch_table(device)->RegisterDisplayEventEXT(device, display, pDisplayEventInfo, pAllocator, pFence); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainCounterEXT(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetSwapchainCounterEXT\n"; - } + Timer timer("vkGetSwapchainCounterEXT"); VkResult result = device_dispatch_table(device)->GetSwapchainCounterEXT(device, swapchain, counter, pCounterValue); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetRefreshCycleDurationGOOGLE(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetRefreshCycleDurationGOOGLE\n"; - } + Timer timer("vkGetRefreshCycleDurationGOOGLE"); VkResult result = device_dispatch_table(device)->GetRefreshCycleDurationGOOGLE(device, swapchain, pDisplayTimingProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPastPresentationTimingGOOGLE(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPastPresentationTimingGOOGLE\n"; - } + Timer timer("vkGetPastPresentationTimingGOOGLE"); VkResult result = device_dispatch_table(device)->GetPastPresentationTimingGOOGLE(device, swapchain, pPresentationTimingCount, pPresentationTimings); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetDiscardRectangleEXT\n"; - } + Timer timer("vkCmdSetDiscardRectangleEXT"); device_dispatch_table(commandBuffer)->CmdSetDiscardRectangleEXT(commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetDiscardRectangleEnableEXT\n"; - } + Timer timer("vkCmdSetDiscardRectangleEnableEXT"); device_dispatch_table(commandBuffer)->CmdSetDiscardRectangleEnableEXT(commandBuffer, discardRectangleEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleModeEXT(VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetDiscardRectangleModeEXT\n"; - } + Timer timer("vkCmdSetDiscardRectangleModeEXT"); device_dispatch_table(commandBuffer)->CmdSetDiscardRectangleModeEXT(commandBuffer, discardRectangleMode); } template VKAPI_ATTR void VKAPI_CALL vkSetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkSetHdrMetadataEXT\n"; - } + Timer timer("vkSetHdrMetadataEXT"); device_dispatch_table(device)->SetHdrMetadataEXT(device, swapchainCount, pSwapchains, pMetadata); } template VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - ApiDumpInstance::current().update_object_name_map(pNameInfo); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkSetDebugUtilsObjectNameEXT\n"; - } + Timer timer("vkSetDebugUtilsObjectNameEXT"); VkResult result = device_dispatch_table(device)->SetDebugUtilsObjectNameEXT(device, pNameInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkSetDebugUtilsObjectTagEXT\n"; - } + Timer timer("vkSetDebugUtilsObjectTagEXT"); VkResult result = device_dispatch_table(device)->SetDebugUtilsObjectTagEXT(device, pTagInfo); return result; } template VKAPI_ATTR void VKAPI_CALL vkQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkQueueBeginDebugUtilsLabelEXT\n"; - } + Timer timer("vkQueueBeginDebugUtilsLabelEXT"); device_dispatch_table(queue)->QueueBeginDebugUtilsLabelEXT(queue, pLabelInfo); } template VKAPI_ATTR void VKAPI_CALL vkQueueEndDebugUtilsLabelEXT(VkQueue queue) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkQueueEndDebugUtilsLabelEXT\n"; - } + Timer timer("vkQueueEndDebugUtilsLabelEXT"); device_dispatch_table(queue)->QueueEndDebugUtilsLabelEXT(queue); } template VKAPI_ATTR void VKAPI_CALL vkQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkQueueInsertDebugUtilsLabelEXT\n"; - } + Timer timer("vkQueueInsertDebugUtilsLabelEXT"); device_dispatch_table(queue)->QueueInsertDebugUtilsLabelEXT(queue, pLabelInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBeginDebugUtilsLabelEXT\n"; - } + Timer timer("vkCmdBeginDebugUtilsLabelEXT"); device_dispatch_table(commandBuffer)->CmdBeginDebugUtilsLabelEXT(commandBuffer, pLabelInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdEndDebugUtilsLabelEXT\n"; - } + Timer timer("vkCmdEndDebugUtilsLabelEXT"); device_dispatch_table(commandBuffer)->CmdEndDebugUtilsLabelEXT(commandBuffer); } template VKAPI_ATTR void VKAPI_CALL vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdInsertDebugUtilsLabelEXT\n"; - } + Timer timer("vkCmdInsertDebugUtilsLabelEXT"); device_dispatch_table(commandBuffer)->CmdInsertDebugUtilsLabelEXT(commandBuffer, pLabelInfo); } #if defined(VK_USE_PLATFORM_ANDROID_KHR) template VKAPI_ATTR VkResult VKAPI_CALL vkGetAndroidHardwareBufferPropertiesANDROID(VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetAndroidHardwareBufferPropertiesANDROID\n"; - } + Timer timer("vkGetAndroidHardwareBufferPropertiesANDROID"); VkResult result = device_dispatch_table(device)->GetAndroidHardwareBufferPropertiesANDROID(device, buffer, pProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryAndroidHardwareBufferANDROID(VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetMemoryAndroidHardwareBufferANDROID\n"; - } + Timer timer("vkGetMemoryAndroidHardwareBufferANDROID"); VkResult result = device_dispatch_table(device)->GetMemoryAndroidHardwareBufferANDROID(device, pInfo, pBuffer); return result; } @@ -4537,2782 +2733,1602 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryAndroidHardwareBufferANDROID(VkDevice #if defined(VK_ENABLE_BETA_EXTENSIONS) template VKAPI_ATTR VkResult VKAPI_CALL vkCreateExecutionGraphPipelinesAMDX(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkExecutionGraphPipelineCreateInfoAMDX* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateExecutionGraphPipelinesAMDX\n"; - } + Timer timer("vkCreateExecutionGraphPipelinesAMDX"); VkResult result = device_dispatch_table(device)->CreateExecutionGraphPipelinesAMDX(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetExecutionGraphPipelineScratchSizeAMDX(VkDevice device, VkPipeline executionGraph, VkExecutionGraphPipelineScratchSizeAMDX* pSizeInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetExecutionGraphPipelineScratchSizeAMDX\n"; - } + Timer timer("vkGetExecutionGraphPipelineScratchSizeAMDX"); VkResult result = device_dispatch_table(device)->GetExecutionGraphPipelineScratchSizeAMDX(device, executionGraph, pSizeInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetExecutionGraphPipelineNodeIndexAMDX(VkDevice device, VkPipeline executionGraph, const VkPipelineShaderStageNodeCreateInfoAMDX* pNodeInfo, uint32_t* pNodeIndex) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetExecutionGraphPipelineNodeIndexAMDX\n"; - } + Timer timer("vkGetExecutionGraphPipelineNodeIndexAMDX"); VkResult result = device_dispatch_table(device)->GetExecutionGraphPipelineNodeIndexAMDX(device, executionGraph, pNodeInfo, pNodeIndex); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdInitializeGraphScratchMemoryAMDX(VkCommandBuffer commandBuffer, VkPipeline executionGraph, VkDeviceAddress scratch, VkDeviceSize scratchSize) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdInitializeGraphScratchMemoryAMDX\n"; - } + Timer timer("vkCmdInitializeGraphScratchMemoryAMDX"); device_dispatch_table(commandBuffer)->CmdInitializeGraphScratchMemoryAMDX(commandBuffer, executionGraph, scratch, scratchSize); } template VKAPI_ATTR void VKAPI_CALL vkCmdDispatchGraphAMDX(VkCommandBuffer commandBuffer, VkDeviceAddress scratch, VkDeviceSize scratchSize, const VkDispatchGraphCountInfoAMDX* pCountInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdDispatchGraphAMDX\n"; - } + Timer timer("vkCmdDispatchGraphAMDX"); device_dispatch_table(commandBuffer)->CmdDispatchGraphAMDX(commandBuffer, scratch, scratchSize, pCountInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdDispatchGraphIndirectAMDX(VkCommandBuffer commandBuffer, VkDeviceAddress scratch, VkDeviceSize scratchSize, const VkDispatchGraphCountInfoAMDX* pCountInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdDispatchGraphIndirectAMDX\n"; - } + Timer timer("vkCmdDispatchGraphIndirectAMDX"); device_dispatch_table(commandBuffer)->CmdDispatchGraphIndirectAMDX(commandBuffer, scratch, scratchSize, pCountInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdDispatchGraphIndirectCountAMDX(VkCommandBuffer commandBuffer, VkDeviceAddress scratch, VkDeviceSize scratchSize, VkDeviceAddress countInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdDispatchGraphIndirectCountAMDX\n"; - } + Timer timer("vkCmdDispatchGraphIndirectCountAMDX"); device_dispatch_table(commandBuffer)->CmdDispatchGraphIndirectCountAMDX(commandBuffer, scratch, scratchSize, countInfo); } #endif // VK_ENABLE_BETA_EXTENSIONS template VKAPI_ATTR VkResult VKAPI_CALL vkWriteSamplerDescriptorsEXT(VkDevice device, uint32_t samplerCount, const VkSamplerCreateInfo* pSamplers, const VkHostAddressRangeEXT* pDescriptors) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkWriteSamplerDescriptorsEXT\n"; - } + Timer timer("vkWriteSamplerDescriptorsEXT"); VkResult result = device_dispatch_table(device)->WriteSamplerDescriptorsEXT(device, samplerCount, pSamplers, pDescriptors); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkWriteResourceDescriptorsEXT(VkDevice device, uint32_t resourceCount, const VkResourceDescriptorInfoEXT* pResources, const VkHostAddressRangeEXT* pDescriptors) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkWriteResourceDescriptorsEXT\n"; - } + Timer timer("vkWriteResourceDescriptorsEXT"); VkResult result = device_dispatch_table(device)->WriteResourceDescriptorsEXT(device, resourceCount, pResources, pDescriptors); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdBindSamplerHeapEXT(VkCommandBuffer commandBuffer, const VkBindHeapInfoEXT* pBindInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBindSamplerHeapEXT\n"; - } + Timer timer("vkCmdBindSamplerHeapEXT"); device_dispatch_table(commandBuffer)->CmdBindSamplerHeapEXT(commandBuffer, pBindInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdBindResourceHeapEXT(VkCommandBuffer commandBuffer, const VkBindHeapInfoEXT* pBindInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBindResourceHeapEXT\n"; - } + Timer timer("vkCmdBindResourceHeapEXT"); device_dispatch_table(commandBuffer)->CmdBindResourceHeapEXT(commandBuffer, pBindInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdPushDataEXT(VkCommandBuffer commandBuffer, const VkPushDataInfoEXT* pPushDataInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdPushDataEXT\n"; - } + Timer timer("vkCmdPushDataEXT"); device_dispatch_table(commandBuffer)->CmdPushDataEXT(commandBuffer, pPushDataInfo); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetImageOpaqueCaptureDataEXT(VkDevice device, uint32_t imageCount, const VkImage* pImages, VkHostAddressRangeEXT* pDatas) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetImageOpaqueCaptureDataEXT\n"; - } + Timer timer("vkGetImageOpaqueCaptureDataEXT"); VkResult result = device_dispatch_table(device)->GetImageOpaqueCaptureDataEXT(device, imageCount, pImages, pDatas); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkRegisterCustomBorderColorEXT(VkDevice device, const VkSamplerCustomBorderColorCreateInfoEXT* pBorderColor, VkBool32 requestIndex, uint32_t* pIndex) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkRegisterCustomBorderColorEXT\n"; - } + Timer timer("vkRegisterCustomBorderColorEXT"); VkResult result = device_dispatch_table(device)->RegisterCustomBorderColorEXT(device, pBorderColor, requestIndex, pIndex); return result; } template VKAPI_ATTR void VKAPI_CALL vkUnregisterCustomBorderColorEXT(VkDevice device, uint32_t index) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkUnregisterCustomBorderColorEXT\n"; - } + Timer timer("vkUnregisterCustomBorderColorEXT"); device_dispatch_table(device)->UnregisterCustomBorderColorEXT(device, index); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetTensorOpaqueCaptureDataARM(VkDevice device, uint32_t tensorCount, const VkTensorARM* pTensors, VkHostAddressRangeEXT* pDatas) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetTensorOpaqueCaptureDataARM\n"; - } + Timer timer("vkGetTensorOpaqueCaptureDataARM"); VkResult result = device_dispatch_table(device)->GetTensorOpaqueCaptureDataARM(device, tensorCount, pTensors, pDatas); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetSampleLocationsEXT\n"; - } + Timer timer("vkCmdSetSampleLocationsEXT"); device_dispatch_table(commandBuffer)->CmdSetSampleLocationsEXT(commandBuffer, pSampleLocationsInfo); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetImageDrmFormatModifierPropertiesEXT\n"; - } + Timer timer("vkGetImageDrmFormatModifierPropertiesEXT"); VkResult result = device_dispatch_table(device)->GetImageDrmFormatModifierPropertiesEXT(device, image, pProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateValidationCacheEXT(VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateValidationCacheEXT\n"; - } + Timer timer("vkCreateValidationCacheEXT"); VkResult result = device_dispatch_table(device)->CreateValidationCacheEXT(device, pCreateInfo, pAllocator, pValidationCache); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyValidationCacheEXT\n"; - } + Timer timer("vkDestroyValidationCacheEXT"); device_dispatch_table(device)->DestroyValidationCacheEXT(device, validationCache, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkMergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkMergeValidationCachesEXT\n"; - } + Timer timer("vkMergeValidationCachesEXT"); VkResult result = device_dispatch_table(device)->MergeValidationCachesEXT(device, dstCache, srcCacheCount, pSrcCaches); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetValidationCacheDataEXT\n"; - } + Timer timer("vkGetValidationCacheDataEXT"); VkResult result = device_dispatch_table(device)->GetValidationCacheDataEXT(device, validationCache, pDataSize, pData); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBindShadingRateImageNV\n"; - } + Timer timer("vkCmdBindShadingRateImageNV"); device_dispatch_table(commandBuffer)->CmdBindShadingRateImageNV(commandBuffer, imageView, imageLayout); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetViewportShadingRatePaletteNV\n"; - } + Timer timer("vkCmdSetViewportShadingRatePaletteNV"); device_dispatch_table(commandBuffer)->CmdSetViewportShadingRatePaletteNV(commandBuffer, firstViewport, viewportCount, pShadingRatePalettes); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetCoarseSampleOrderNV\n"; - } + Timer timer("vkCmdSetCoarseSampleOrderNV"); device_dispatch_table(commandBuffer)->CmdSetCoarseSampleOrderNV(commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateAccelerationStructureNV(VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateAccelerationStructureNV\n"; - } + Timer timer("vkCreateAccelerationStructureNV"); VkResult result = device_dispatch_table(device)->CreateAccelerationStructureNV(device, pCreateInfo, pAllocator, pAccelerationStructure); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyAccelerationStructureNV\n"; - } + Timer timer("vkDestroyAccelerationStructureNV"); device_dispatch_table(device)->DestroyAccelerationStructureNV(device, accelerationStructure, pAllocator); } template VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureMemoryRequirementsNV(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetAccelerationStructureMemoryRequirementsNV\n"; - } + Timer timer("vkGetAccelerationStructureMemoryRequirementsNV"); device_dispatch_table(device)->GetAccelerationStructureMemoryRequirementsNV(device, pInfo, pMemoryRequirements); } template VKAPI_ATTR VkResult VKAPI_CALL vkBindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkBindAccelerationStructureMemoryNV\n"; - } + Timer timer("vkBindAccelerationStructureMemoryNV"); VkResult result = device_dispatch_table(device)->BindAccelerationStructureMemoryNV(device, bindInfoCount, pBindInfos); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBuildAccelerationStructureNV\n"; - } + Timer timer("vkCmdBuildAccelerationStructureNV"); device_dispatch_table(commandBuffer)->CmdBuildAccelerationStructureNV(commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset); } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdCopyAccelerationStructureNV\n"; - } + Timer timer("vkCmdCopyAccelerationStructureNV"); device_dispatch_table(commandBuffer)->CmdCopyAccelerationStructureNV(commandBuffer, dst, src, mode); } template VKAPI_ATTR void VKAPI_CALL 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) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdTraceRaysNV\n"; - } + Timer timer("vkCmdTraceRaysNV"); device_dispatch_table(commandBuffer)->CmdTraceRaysNV(commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateRayTracingPipelinesNV\n"; - } + Timer timer("vkCreateRayTracingPipelinesNV"); VkResult result = device_dispatch_table(device)->CreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetRayTracingShaderGroupHandlesKHR\n"; - } + Timer timer("vkGetRayTracingShaderGroupHandlesKHR"); VkResult result = device_dispatch_table(device)->GetRayTracingShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount, dataSize, pData); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetRayTracingShaderGroupHandlesNV\n"; - } + Timer timer("vkGetRayTracingShaderGroupHandlesNV"); VkResult result = device_dispatch_table(device)->GetRayTracingShaderGroupHandlesNV(device, pipeline, firstGroup, groupCount, dataSize, pData); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetAccelerationStructureHandleNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetAccelerationStructureHandleNV\n"; - } + Timer timer("vkGetAccelerationStructureHandleNV"); VkResult result = device_dispatch_table(device)->GetAccelerationStructureHandleNV(device, accelerationStructure, dataSize, pData); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdWriteAccelerationStructuresPropertiesNV\n"; - } + Timer timer("vkCmdWriteAccelerationStructuresPropertiesNV"); device_dispatch_table(commandBuffer)->CmdWriteAccelerationStructuresPropertiesNV(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery); } template VKAPI_ATTR VkResult VKAPI_CALL vkCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCompileDeferredNV\n"; - } + Timer timer("vkCompileDeferredNV"); VkResult result = device_dispatch_table(device)->CompileDeferredNV(device, pipeline, shader); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetMemoryHostPointerPropertiesEXT\n"; - } + Timer timer("vkGetMemoryHostPointerPropertiesEXT"); VkResult result = device_dispatch_table(device)->GetMemoryHostPointerPropertiesEXT(device, handleType, pHostPointer, pMemoryHostPointerProperties); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdWriteBufferMarkerAMD\n"; - } + Timer timer("vkCmdWriteBufferMarkerAMD"); device_dispatch_table(commandBuffer)->CmdWriteBufferMarkerAMD(commandBuffer, pipelineStage, dstBuffer, dstOffset, marker); } template VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdWriteBufferMarker2AMD\n"; - } + Timer timer("vkCmdWriteBufferMarker2AMD"); device_dispatch_table(commandBuffer)->CmdWriteBufferMarker2AMD(commandBuffer, stage, dstBuffer, dstOffset, marker); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetCalibratedTimestampsEXT\n"; - } + Timer timer("vkGetCalibratedTimestampsEXT"); VkResult result = device_dispatch_table(device)->GetCalibratedTimestampsEXT(device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdDrawMeshTasksNV\n"; - } + Timer timer("vkCmdDrawMeshTasksNV"); device_dispatch_table(commandBuffer)->CmdDrawMeshTasksNV(commandBuffer, taskCount, firstTask); } template VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdDrawMeshTasksIndirectNV\n"; - } + Timer timer("vkCmdDrawMeshTasksIndirectNV"); device_dispatch_table(commandBuffer)->CmdDrawMeshTasksIndirectNV(commandBuffer, buffer, offset, drawCount, stride); } template VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdDrawMeshTasksIndirectCountNV\n"; - } + Timer timer("vkCmdDrawMeshTasksIndirectCountNV"); device_dispatch_table(commandBuffer)->CmdDrawMeshTasksIndirectCountNV(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetExclusiveScissorEnableNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkBool32* pExclusiveScissorEnables) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetExclusiveScissorEnableNV\n"; - } + Timer timer("vkCmdSetExclusiveScissorEnableNV"); device_dispatch_table(commandBuffer)->CmdSetExclusiveScissorEnableNV(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissorEnables); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetExclusiveScissorNV\n"; - } + Timer timer("vkCmdSetExclusiveScissorNV"); device_dispatch_table(commandBuffer)->CmdSetExclusiveScissorNV(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void* pCheckpointMarker) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetCheckpointNV\n"; - } + Timer timer("vkCmdSetCheckpointNV"); device_dispatch_table(commandBuffer)->CmdSetCheckpointNV(commandBuffer, pCheckpointMarker); } template VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointDataNV(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetQueueCheckpointDataNV\n"; - } + Timer timer("vkGetQueueCheckpointDataNV"); device_dispatch_table(queue)->GetQueueCheckpointDataNV(queue, pCheckpointDataCount, pCheckpointData); } template VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointData2NV(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetQueueCheckpointData2NV\n"; - } + Timer timer("vkGetQueueCheckpointData2NV"); device_dispatch_table(queue)->GetQueueCheckpointData2NV(queue, pCheckpointDataCount, pCheckpointData); } template VKAPI_ATTR VkResult VKAPI_CALL vkSetSwapchainPresentTimingQueueSizeEXT(VkDevice device, VkSwapchainKHR swapchain, uint32_t size) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkSetSwapchainPresentTimingQueueSizeEXT\n"; - } + Timer timer("vkSetSwapchainPresentTimingQueueSizeEXT"); VkResult result = device_dispatch_table(device)->SetSwapchainPresentTimingQueueSizeEXT(device, swapchain, size); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainTimingPropertiesEXT(VkDevice device, VkSwapchainKHR swapchain, VkSwapchainTimingPropertiesEXT* pSwapchainTimingProperties, uint64_t* pSwapchainTimingPropertiesCounter) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetSwapchainTimingPropertiesEXT\n"; - } + Timer timer("vkGetSwapchainTimingPropertiesEXT"); VkResult result = device_dispatch_table(device)->GetSwapchainTimingPropertiesEXT(device, swapchain, pSwapchainTimingProperties, pSwapchainTimingPropertiesCounter); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainTimeDomainPropertiesEXT(VkDevice device, VkSwapchainKHR swapchain, VkSwapchainTimeDomainPropertiesEXT* pSwapchainTimeDomainProperties, uint64_t* pTimeDomainsCounter) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetSwapchainTimeDomainPropertiesEXT\n"; - } + Timer timer("vkGetSwapchainTimeDomainPropertiesEXT"); VkResult result = device_dispatch_table(device)->GetSwapchainTimeDomainPropertiesEXT(device, swapchain, pSwapchainTimeDomainProperties, pTimeDomainsCounter); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPastPresentationTimingEXT(VkDevice device, const VkPastPresentationTimingInfoEXT* pPastPresentationTimingInfo, VkPastPresentationTimingPropertiesEXT* pPastPresentationTimingProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPastPresentationTimingEXT\n"; - } + Timer timer("vkGetPastPresentationTimingEXT"); VkResult result = device_dispatch_table(device)->GetPastPresentationTimingEXT(device, pPastPresentationTimingInfo, pPastPresentationTimingProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkInitializePerformanceApiINTEL(VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkInitializePerformanceApiINTEL\n"; - } + Timer timer("vkInitializePerformanceApiINTEL"); VkResult result = device_dispatch_table(device)->InitializePerformanceApiINTEL(device, pInitializeInfo); return result; } template VKAPI_ATTR void VKAPI_CALL vkUninitializePerformanceApiINTEL(VkDevice device) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkUninitializePerformanceApiINTEL\n"; - } + Timer timer("vkUninitializePerformanceApiINTEL"); device_dispatch_table(device)->UninitializePerformanceApiINTEL(device); } template VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetPerformanceMarkerINTEL\n"; - } + Timer timer("vkCmdSetPerformanceMarkerINTEL"); VkResult result = device_dispatch_table(commandBuffer)->CmdSetPerformanceMarkerINTEL(commandBuffer, pMarkerInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetPerformanceStreamMarkerINTEL\n"; - } + Timer timer("vkCmdSetPerformanceStreamMarkerINTEL"); VkResult result = device_dispatch_table(commandBuffer)->CmdSetPerformanceStreamMarkerINTEL(commandBuffer, pMarkerInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetPerformanceOverrideINTEL\n"; - } + Timer timer("vkCmdSetPerformanceOverrideINTEL"); VkResult result = device_dispatch_table(commandBuffer)->CmdSetPerformanceOverrideINTEL(commandBuffer, pOverrideInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkAcquirePerformanceConfigurationINTEL(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkAcquirePerformanceConfigurationINTEL\n"; - } + Timer timer("vkAcquirePerformanceConfigurationINTEL"); VkResult result = device_dispatch_table(device)->AcquirePerformanceConfigurationINTEL(device, pAcquireInfo, pConfiguration); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkReleasePerformanceConfigurationINTEL(VkDevice device, VkPerformanceConfigurationINTEL configuration) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkReleasePerformanceConfigurationINTEL\n"; - } + Timer timer("vkReleasePerformanceConfigurationINTEL"); VkResult result = device_dispatch_table(device)->ReleasePerformanceConfigurationINTEL(device, configuration); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkQueueSetPerformanceConfigurationINTEL(VkQueue queue, VkPerformanceConfigurationINTEL configuration) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkQueueSetPerformanceConfigurationINTEL\n"; - } + Timer timer("vkQueueSetPerformanceConfigurationINTEL"); VkResult result = device_dispatch_table(queue)->QueueSetPerformanceConfigurationINTEL(queue, configuration); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPerformanceParameterINTEL\n"; - } + Timer timer("vkGetPerformanceParameterINTEL"); VkResult result = device_dispatch_table(device)->GetPerformanceParameterINTEL(device, parameter, pValue); return result; } template VKAPI_ATTR void VKAPI_CALL vkSetLocalDimmingAMD(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkSetLocalDimmingAMD\n"; - } + Timer timer("vkSetLocalDimmingAMD"); device_dispatch_table(device)->SetLocalDimmingAMD(device, swapChain, localDimmingEnable); } template VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressEXT(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetBufferDeviceAddressEXT\n"; - } + Timer timer("vkGetBufferDeviceAddressEXT"); VkDeviceAddress result = device_dispatch_table(device)->GetBufferDeviceAddressEXT(device, pInfo); return result; } #if defined(VK_USE_PLATFORM_WIN32_KHR) template VKAPI_ATTR VkResult VKAPI_CALL vkAcquireFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkAcquireFullScreenExclusiveModeEXT\n"; - } + Timer timer("vkAcquireFullScreenExclusiveModeEXT"); VkResult result = device_dispatch_table(device)->AcquireFullScreenExclusiveModeEXT(device, swapchain); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkReleaseFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkReleaseFullScreenExclusiveModeEXT\n"; - } + Timer timer("vkReleaseFullScreenExclusiveModeEXT"); VkResult result = device_dispatch_table(device)->ReleaseFullScreenExclusiveModeEXT(device, swapchain); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModes2EXT(VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDeviceGroupSurfacePresentModes2EXT\n"; - } + Timer timer("vkGetDeviceGroupSurfacePresentModes2EXT"); VkResult result = device_dispatch_table(device)->GetDeviceGroupSurfacePresentModes2EXT(device, pSurfaceInfo, pModes); return result; } #endif // VK_USE_PLATFORM_WIN32_KHR template VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetLineStippleEXT\n"; - } + Timer timer("vkCmdSetLineStippleEXT"); device_dispatch_table(commandBuffer)->CmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern); } template VKAPI_ATTR void VKAPI_CALL vkResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkResetQueryPoolEXT\n"; - } + Timer timer("vkResetQueryPoolEXT"); device_dispatch_table(device)->ResetQueryPoolEXT(device, queryPool, firstQuery, queryCount); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetCullModeEXT\n"; - } + Timer timer("vkCmdSetCullModeEXT"); device_dispatch_table(commandBuffer)->CmdSetCullModeEXT(commandBuffer, cullMode); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetFrontFaceEXT\n"; - } + Timer timer("vkCmdSetFrontFaceEXT"); device_dispatch_table(commandBuffer)->CmdSetFrontFaceEXT(commandBuffer, frontFace); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetPrimitiveTopologyEXT\n"; - } + Timer timer("vkCmdSetPrimitiveTopologyEXT"); device_dispatch_table(commandBuffer)->CmdSetPrimitiveTopologyEXT(commandBuffer, primitiveTopology); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetViewportWithCountEXT\n"; - } + Timer timer("vkCmdSetViewportWithCountEXT"); device_dispatch_table(commandBuffer)->CmdSetViewportWithCountEXT(commandBuffer, viewportCount, pViewports); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetScissorWithCountEXT\n"; - } + Timer timer("vkCmdSetScissorWithCountEXT"); device_dispatch_table(commandBuffer)->CmdSetScissorWithCountEXT(commandBuffer, scissorCount, pScissors); } template VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBindVertexBuffers2EXT\n"; - } + Timer timer("vkCmdBindVertexBuffers2EXT"); device_dispatch_table(commandBuffer)->CmdBindVertexBuffers2EXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetDepthTestEnableEXT\n"; - } + Timer timer("vkCmdSetDepthTestEnableEXT"); device_dispatch_table(commandBuffer)->CmdSetDepthTestEnableEXT(commandBuffer, depthTestEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetDepthWriteEnableEXT\n"; - } + Timer timer("vkCmdSetDepthWriteEnableEXT"); device_dispatch_table(commandBuffer)->CmdSetDepthWriteEnableEXT(commandBuffer, depthWriteEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetDepthCompareOpEXT\n"; - } + Timer timer("vkCmdSetDepthCompareOpEXT"); device_dispatch_table(commandBuffer)->CmdSetDepthCompareOpEXT(commandBuffer, depthCompareOp); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetDepthBoundsTestEnableEXT\n"; - } + Timer timer("vkCmdSetDepthBoundsTestEnableEXT"); device_dispatch_table(commandBuffer)->CmdSetDepthBoundsTestEnableEXT(commandBuffer, depthBoundsTestEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetStencilTestEnableEXT\n"; - } + Timer timer("vkCmdSetStencilTestEnableEXT"); device_dispatch_table(commandBuffer)->CmdSetStencilTestEnableEXT(commandBuffer, stencilTestEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilOpEXT(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetStencilOpEXT\n"; - } + Timer timer("vkCmdSetStencilOpEXT"); device_dispatch_table(commandBuffer)->CmdSetStencilOpEXT(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp); } template VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToImageEXT(VkDevice device, const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCopyMemoryToImageEXT\n"; - } + Timer timer("vkCopyMemoryToImageEXT"); VkResult result = device_dispatch_table(device)->CopyMemoryToImageEXT(device, pCopyMemoryToImageInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCopyImageToMemoryEXT(VkDevice device, const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCopyImageToMemoryEXT\n"; - } + Timer timer("vkCopyImageToMemoryEXT"); VkResult result = device_dispatch_table(device)->CopyImageToMemoryEXT(device, pCopyImageToMemoryInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCopyImageToImageEXT(VkDevice device, const VkCopyImageToImageInfo* pCopyImageToImageInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCopyImageToImageEXT\n"; - } + Timer timer("vkCopyImageToImageEXT"); VkResult result = device_dispatch_table(device)->CopyImageToImageEXT(device, pCopyImageToImageInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkTransitionImageLayoutEXT(VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfo* pTransitions) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkTransitionImageLayoutEXT\n"; - } + Timer timer("vkTransitionImageLayoutEXT"); VkResult result = device_dispatch_table(device)->TransitionImageLayoutEXT(device, transitionCount, pTransitions); return result; } template VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout2EXT(VkDevice device, VkImage image, const VkImageSubresource2* pSubresource, VkSubresourceLayout2* pLayout) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetImageSubresourceLayout2EXT\n"; - } + Timer timer("vkGetImageSubresourceLayout2EXT"); device_dispatch_table(device)->GetImageSubresourceLayout2EXT(device, image, pSubresource, pLayout); } template VKAPI_ATTR VkResult VKAPI_CALL vkReleaseSwapchainImagesEXT(VkDevice device, const VkReleaseSwapchainImagesInfoKHR* pReleaseInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkReleaseSwapchainImagesEXT\n"; - } + Timer timer("vkReleaseSwapchainImagesEXT"); VkResult result = device_dispatch_table(device)->ReleaseSwapchainImagesEXT(device, pReleaseInfo); return result; } template VKAPI_ATTR void VKAPI_CALL vkGetGeneratedCommandsMemoryRequirementsNV(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2* pMemoryRequirements) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetGeneratedCommandsMemoryRequirementsNV\n"; - } + Timer timer("vkGetGeneratedCommandsMemoryRequirementsNV"); device_dispatch_table(device)->GetGeneratedCommandsMemoryRequirementsNV(device, pInfo, pMemoryRequirements); } template VKAPI_ATTR void VKAPI_CALL vkCmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdPreprocessGeneratedCommandsNV\n"; - } + Timer timer("vkCmdPreprocessGeneratedCommandsNV"); device_dispatch_table(commandBuffer)->CmdPreprocessGeneratedCommandsNV(commandBuffer, pGeneratedCommandsInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdExecuteGeneratedCommandsNV\n"; - } + Timer timer("vkCmdExecuteGeneratedCommandsNV"); device_dispatch_table(commandBuffer)->CmdExecuteGeneratedCommandsNV(commandBuffer, isPreprocessed, pGeneratedCommandsInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBindPipelineShaderGroupNV\n"; - } + Timer timer("vkCmdBindPipelineShaderGroupNV"); device_dispatch_table(commandBuffer)->CmdBindPipelineShaderGroupNV(commandBuffer, pipelineBindPoint, pipeline, groupIndex); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutNV(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNV* pIndirectCommandsLayout) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateIndirectCommandsLayoutNV\n"; - } + Timer timer("vkCreateIndirectCommandsLayoutNV"); VkResult result = device_dispatch_table(device)->CreateIndirectCommandsLayoutNV(device, pCreateInfo, pAllocator, pIndirectCommandsLayout); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutNV(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyIndirectCommandsLayoutNV\n"; - } + Timer timer("vkDestroyIndirectCommandsLayoutNV"); device_dispatch_table(device)->DestroyIndirectCommandsLayoutNV(device, indirectCommandsLayout, pAllocator); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias2EXT(VkCommandBuffer commandBuffer, const VkDepthBiasInfoEXT* pDepthBiasInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetDepthBias2EXT\n"; - } + Timer timer("vkCmdSetDepthBias2EXT"); device_dispatch_table(commandBuffer)->CmdSetDepthBias2EXT(commandBuffer, pDepthBiasInfo); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreatePrivateDataSlotEXT(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreatePrivateDataSlotEXT\n"; - } + Timer timer("vkCreatePrivateDataSlotEXT"); VkResult result = device_dispatch_table(device)->CreatePrivateDataSlotEXT(device, pCreateInfo, pAllocator, pPrivateDataSlot); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyPrivateDataSlotEXT\n"; - } + Timer timer("vkDestroyPrivateDataSlotEXT"); device_dispatch_table(device)->DestroyPrivateDataSlotEXT(device, privateDataSlot, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkSetPrivateDataEXT\n"; - } + Timer timer("vkSetPrivateDataEXT"); VkResult result = device_dispatch_table(device)->SetPrivateDataEXT(device, objectType, objectHandle, privateDataSlot, data); return result; } template VKAPI_ATTR void VKAPI_CALL vkGetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPrivateDataEXT\n"; - } + Timer timer("vkGetPrivateDataEXT"); device_dispatch_table(device)->GetPrivateDataEXT(device, objectType, objectHandle, privateDataSlot, pData); } #if defined(VK_ENABLE_BETA_EXTENSIONS) template VKAPI_ATTR VkResult VKAPI_CALL vkCreateCudaModuleNV(VkDevice device, const VkCudaModuleCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCudaModuleNV* pModule) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateCudaModuleNV\n"; - } + Timer timer("vkCreateCudaModuleNV"); VkResult result = device_dispatch_table(device)->CreateCudaModuleNV(device, pCreateInfo, pAllocator, pModule); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetCudaModuleCacheNV(VkDevice device, VkCudaModuleNV module, size_t* pCacheSize, void* pCacheData) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetCudaModuleCacheNV\n"; - } + Timer timer("vkGetCudaModuleCacheNV"); VkResult result = device_dispatch_table(device)->GetCudaModuleCacheNV(device, module, pCacheSize, pCacheData); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateCudaFunctionNV(VkDevice device, const VkCudaFunctionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCudaFunctionNV* pFunction) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateCudaFunctionNV\n"; - } + Timer timer("vkCreateCudaFunctionNV"); VkResult result = device_dispatch_table(device)->CreateCudaFunctionNV(device, pCreateInfo, pAllocator, pFunction); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyCudaModuleNV(VkDevice device, VkCudaModuleNV module, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyCudaModuleNV\n"; - } + Timer timer("vkDestroyCudaModuleNV"); device_dispatch_table(device)->DestroyCudaModuleNV(device, module, pAllocator); } template VKAPI_ATTR void VKAPI_CALL vkDestroyCudaFunctionNV(VkDevice device, VkCudaFunctionNV function, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyCudaFunctionNV\n"; - } + Timer timer("vkDestroyCudaFunctionNV"); device_dispatch_table(device)->DestroyCudaFunctionNV(device, function, pAllocator); } template VKAPI_ATTR void VKAPI_CALL vkCmdCudaLaunchKernelNV(VkCommandBuffer commandBuffer, const VkCudaLaunchInfoNV* pLaunchInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdCudaLaunchKernelNV\n"; - } + Timer timer("vkCmdCudaLaunchKernelNV"); device_dispatch_table(commandBuffer)->CmdCudaLaunchKernelNV(commandBuffer, pLaunchInfo); } #endif // VK_ENABLE_BETA_EXTENSIONS template VKAPI_ATTR void VKAPI_CALL vkCmdDispatchTileQCOM(VkCommandBuffer commandBuffer, const VkDispatchTileInfoQCOM* pDispatchTileInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdDispatchTileQCOM\n"; - } + Timer timer("vkCmdDispatchTileQCOM"); device_dispatch_table(commandBuffer)->CmdDispatchTileQCOM(commandBuffer, pDispatchTileInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdBeginPerTileExecutionQCOM(VkCommandBuffer commandBuffer, const VkPerTileBeginInfoQCOM* pPerTileBeginInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBeginPerTileExecutionQCOM\n"; - } + Timer timer("vkCmdBeginPerTileExecutionQCOM"); device_dispatch_table(commandBuffer)->CmdBeginPerTileExecutionQCOM(commandBuffer, pPerTileBeginInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdEndPerTileExecutionQCOM(VkCommandBuffer commandBuffer, const VkPerTileEndInfoQCOM* pPerTileEndInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdEndPerTileExecutionQCOM\n"; - } + Timer timer("vkCmdEndPerTileExecutionQCOM"); device_dispatch_table(commandBuffer)->CmdEndPerTileExecutionQCOM(commandBuffer, pPerTileEndInfo); } #if defined(VK_USE_PLATFORM_METAL_EXT) template VKAPI_ATTR void VKAPI_CALL vkExportMetalObjectsEXT(VkDevice device, VkExportMetalObjectsInfoEXT* pMetalObjectsInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkExportMetalObjectsEXT\n"; - } + Timer timer("vkExportMetalObjectsEXT"); device_dispatch_table(device)->ExportMetalObjectsEXT(device, pMetalObjectsInfo); } #endif // VK_USE_PLATFORM_METAL_EXT template VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSizeEXT(VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize* pLayoutSizeInBytes) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDescriptorSetLayoutSizeEXT\n"; - } + Timer timer("vkGetDescriptorSetLayoutSizeEXT"); device_dispatch_table(device)->GetDescriptorSetLayoutSizeEXT(device, layout, pLayoutSizeInBytes); } template VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutBindingOffsetEXT(VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize* pOffset) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDescriptorSetLayoutBindingOffsetEXT\n"; - } + Timer timer("vkGetDescriptorSetLayoutBindingOffsetEXT"); device_dispatch_table(device)->GetDescriptorSetLayoutBindingOffsetEXT(device, layout, binding, pOffset); } template VKAPI_ATTR void VKAPI_CALL vkGetDescriptorEXT(VkDevice device, const VkDescriptorGetInfoEXT* pDescriptorInfo, size_t dataSize, void* pDescriptor) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDescriptorEXT\n"; - } + Timer timer("vkGetDescriptorEXT"); device_dispatch_table(device)->GetDescriptorEXT(device, pDescriptorInfo, dataSize, pDescriptor); } template VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorBuffersEXT(VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT* pBindingInfos) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBindDescriptorBuffersEXT\n"; - } + Timer timer("vkCmdBindDescriptorBuffersEXT"); device_dispatch_table(commandBuffer)->CmdBindDescriptorBuffersEXT(commandBuffer, bufferCount, pBindingInfos); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDescriptorBufferOffsetsEXT(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t* pBufferIndices, const VkDeviceSize* pOffsets) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetDescriptorBufferOffsetsEXT\n"; - } + Timer timer("vkCmdSetDescriptorBufferOffsetsEXT"); device_dispatch_table(commandBuffer)->CmdSetDescriptorBufferOffsetsEXT(commandBuffer, pipelineBindPoint, layout, firstSet, setCount, pBufferIndices, pOffsets); } template VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorBufferEmbeddedSamplersEXT(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBindDescriptorBufferEmbeddedSamplersEXT\n"; - } + Timer timer("vkCmdBindDescriptorBufferEmbeddedSamplersEXT"); device_dispatch_table(commandBuffer)->CmdBindDescriptorBufferEmbeddedSamplersEXT(commandBuffer, pipelineBindPoint, layout, set); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetBufferOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT* pInfo, void* pData) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetBufferOpaqueCaptureDescriptorDataEXT\n"; - } + Timer timer("vkGetBufferOpaqueCaptureDescriptorDataEXT"); VkResult result = device_dispatch_table(device)->GetBufferOpaqueCaptureDescriptorDataEXT(device, pInfo, pData); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetImageOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkImageCaptureDescriptorDataInfoEXT* pInfo, void* pData) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetImageOpaqueCaptureDescriptorDataEXT\n"; - } + Timer timer("vkGetImageOpaqueCaptureDescriptorDataEXT"); VkResult result = device_dispatch_table(device)->GetImageOpaqueCaptureDescriptorDataEXT(device, pInfo, pData); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetImageViewOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, void* pData) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetImageViewOpaqueCaptureDescriptorDataEXT\n"; - } + Timer timer("vkGetImageViewOpaqueCaptureDescriptorDataEXT"); VkResult result = device_dispatch_table(device)->GetImageViewOpaqueCaptureDescriptorDataEXT(device, pInfo, pData); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetSamplerOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT* pInfo, void* pData) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetSamplerOpaqueCaptureDescriptorDataEXT\n"; - } + Timer timer("vkGetSamplerOpaqueCaptureDescriptorDataEXT"); VkResult result = device_dispatch_table(device)->GetSamplerOpaqueCaptureDescriptorDataEXT(device, pInfo, pData); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, void* pData) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT\n"; - } + Timer timer("vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT"); VkResult result = device_dispatch_table(device)->GetAccelerationStructureOpaqueCaptureDescriptorDataEXT(device, pInfo, pData); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateEnumNV(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetFragmentShadingRateEnumNV\n"; - } + Timer timer("vkCmdSetFragmentShadingRateEnumNV"); device_dispatch_table(commandBuffer)->CmdSetFragmentShadingRateEnumNV(commandBuffer, shadingRate, combinerOps); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceFaultInfoEXT(VkDevice device, VkDeviceFaultCountsEXT* pFaultCounts, VkDeviceFaultInfoEXT* pFaultInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDeviceFaultInfoEXT\n"; - } + Timer timer("vkGetDeviceFaultInfoEXT"); VkResult result = device_dispatch_table(device)->GetDeviceFaultInfoEXT(device, pFaultCounts, pFaultInfo); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdSetVertexInputEXT(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetVertexInputEXT\n"; - } + Timer timer("vkCmdSetVertexInputEXT"); device_dispatch_table(commandBuffer)->CmdSetVertexInputEXT(commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions); } #if defined(VK_USE_PLATFORM_FUCHSIA) template VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryZirconHandleFUCHSIA(VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetMemoryZirconHandleFUCHSIA\n"; - } + Timer timer("vkGetMemoryZirconHandleFUCHSIA"); VkResult result = device_dispatch_table(device)->GetMemoryZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryZirconHandlePropertiesFUCHSIA(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetMemoryZirconHandlePropertiesFUCHSIA\n"; - } + Timer timer("vkGetMemoryZirconHandlePropertiesFUCHSIA"); VkResult result = device_dispatch_table(device)->GetMemoryZirconHandlePropertiesFUCHSIA(device, handleType, zirconHandle, pMemoryZirconHandleProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreZirconHandleFUCHSIA(VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkImportSemaphoreZirconHandleFUCHSIA\n"; - } + Timer timer("vkImportSemaphoreZirconHandleFUCHSIA"); VkResult result = device_dispatch_table(device)->ImportSemaphoreZirconHandleFUCHSIA(device, pImportSemaphoreZirconHandleInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreZirconHandleFUCHSIA(VkDevice device, const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetSemaphoreZirconHandleFUCHSIA\n"; - } + Timer timer("vkGetSemaphoreZirconHandleFUCHSIA"); VkResult result = device_dispatch_table(device)->GetSemaphoreZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferCollectionFUCHSIA(VkDevice device, const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferCollectionFUCHSIA* pCollection) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateBufferCollectionFUCHSIA\n"; - } + Timer timer("vkCreateBufferCollectionFUCHSIA"); VkResult result = device_dispatch_table(device)->CreateBufferCollectionFUCHSIA(device, pCreateInfo, pAllocator, pCollection); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkSetBufferCollectionImageConstraintsFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkSetBufferCollectionImageConstraintsFUCHSIA\n"; - } + Timer timer("vkSetBufferCollectionImageConstraintsFUCHSIA"); VkResult result = device_dispatch_table(device)->SetBufferCollectionImageConstraintsFUCHSIA(device, collection, pImageConstraintsInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkSetBufferCollectionBufferConstraintsFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkSetBufferCollectionBufferConstraintsFUCHSIA\n"; - } + Timer timer("vkSetBufferCollectionBufferConstraintsFUCHSIA"); VkResult result = device_dispatch_table(device)->SetBufferCollectionBufferConstraintsFUCHSIA(device, collection, pBufferConstraintsInfo); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyBufferCollectionFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyBufferCollectionFUCHSIA\n"; - } + Timer timer("vkDestroyBufferCollectionFUCHSIA"); device_dispatch_table(device)->DestroyBufferCollectionFUCHSIA(device, collection, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetBufferCollectionPropertiesFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, VkBufferCollectionPropertiesFUCHSIA* pProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetBufferCollectionPropertiesFUCHSIA\n"; - } + Timer timer("vkGetBufferCollectionPropertiesFUCHSIA"); VkResult result = device_dispatch_table(device)->GetBufferCollectionPropertiesFUCHSIA(device, collection, pProperties); return result; } #endif // VK_USE_PLATFORM_FUCHSIA template VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(VkDevice device, VkRenderPass renderpass, VkExtent2D* pMaxWorkgroupSize) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI\n"; - } + Timer timer("vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI"); VkResult result = device_dispatch_table(device)->GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(device, renderpass, pMaxWorkgroupSize); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdSubpassShadingHUAWEI(VkCommandBuffer commandBuffer) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSubpassShadingHUAWEI\n"; - } + Timer timer("vkCmdSubpassShadingHUAWEI"); device_dispatch_table(commandBuffer)->CmdSubpassShadingHUAWEI(commandBuffer); } template VKAPI_ATTR void VKAPI_CALL vkCmdBindInvocationMaskHUAWEI(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBindInvocationMaskHUAWEI\n"; - } + Timer timer("vkCmdBindInvocationMaskHUAWEI"); device_dispatch_table(commandBuffer)->CmdBindInvocationMaskHUAWEI(commandBuffer, imageView, imageLayout); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryRemoteAddressNV(VkDevice device, const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, VkRemoteAddressNV* pAddress) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetMemoryRemoteAddressNV\n"; - } + Timer timer("vkGetMemoryRemoteAddressNV"); VkResult result = device_dispatch_table(device)->GetMemoryRemoteAddressNV(device, pMemoryGetRemoteAddressInfo, pAddress); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelinePropertiesEXT(VkDevice device, const VkPipelineInfoEXT* pPipelineInfo, VkBaseOutStructure* pPipelineProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPipelinePropertiesEXT\n"; - } + Timer timer("vkGetPipelinePropertiesEXT"); VkResult result = device_dispatch_table(device)->GetPipelinePropertiesEXT(device, pPipelineInfo, pPipelineProperties); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetPatchControlPointsEXT\n"; - } + Timer timer("vkCmdSetPatchControlPointsEXT"); device_dispatch_table(commandBuffer)->CmdSetPatchControlPointsEXT(commandBuffer, patchControlPoints); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetRasterizerDiscardEnableEXT\n"; - } + Timer timer("vkCmdSetRasterizerDiscardEnableEXT"); device_dispatch_table(commandBuffer)->CmdSetRasterizerDiscardEnableEXT(commandBuffer, rasterizerDiscardEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetDepthBiasEnableEXT\n"; - } + Timer timer("vkCmdSetDepthBiasEnableEXT"); device_dispatch_table(commandBuffer)->CmdSetDepthBiasEnableEXT(commandBuffer, depthBiasEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetLogicOpEXT\n"; - } + Timer timer("vkCmdSetLogicOpEXT"); device_dispatch_table(commandBuffer)->CmdSetLogicOpEXT(commandBuffer, logicOp); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetPrimitiveRestartEnableEXT\n"; - } + Timer timer("vkCmdSetPrimitiveRestartEnableEXT"); device_dispatch_table(commandBuffer)->CmdSetPrimitiveRestartEnableEXT(commandBuffer, primitiveRestartEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetColorWriteEnableEXT\n"; - } + Timer timer("vkCmdSetColorWriteEnableEXT"); device_dispatch_table(commandBuffer)->CmdSetColorWriteEnableEXT(commandBuffer, attachmentCount, pColorWriteEnables); } template VKAPI_ATTR void VKAPI_CALL vkCmdDrawMultiEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdDrawMultiEXT\n"; - } + Timer timer("vkCmdDrawMultiEXT"); device_dispatch_table(commandBuffer)->CmdDrawMultiEXT(commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride); } template VKAPI_ATTR void VKAPI_CALL vkCmdDrawMultiIndexedEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdDrawMultiIndexedEXT\n"; - } + Timer timer("vkCmdDrawMultiIndexedEXT"); device_dispatch_table(commandBuffer)->CmdDrawMultiIndexedEXT(commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateMicromapEXT(VkDevice device, const VkMicromapCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkMicromapEXT* pMicromap) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateMicromapEXT\n"; - } + Timer timer("vkCreateMicromapEXT"); VkResult result = device_dispatch_table(device)->CreateMicromapEXT(device, pCreateInfo, pAllocator, pMicromap); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyMicromapEXT(VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyMicromapEXT\n"; - } + Timer timer("vkDestroyMicromapEXT"); device_dispatch_table(device)->DestroyMicromapEXT(device, micromap, pAllocator); } template VKAPI_ATTR void VKAPI_CALL vkCmdBuildMicromapsEXT(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBuildMicromapsEXT\n"; - } + Timer timer("vkCmdBuildMicromapsEXT"); device_dispatch_table(commandBuffer)->CmdBuildMicromapsEXT(commandBuffer, infoCount, pInfos); } template VKAPI_ATTR VkResult VKAPI_CALL vkBuildMicromapsEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkBuildMicromapsEXT\n"; - } + Timer timer("vkBuildMicromapsEXT"); VkResult result = device_dispatch_table(device)->BuildMicromapsEXT(device, deferredOperation, infoCount, pInfos); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCopyMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT* pInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCopyMicromapEXT\n"; - } + Timer timer("vkCopyMicromapEXT"); VkResult result = device_dispatch_table(device)->CopyMicromapEXT(device, deferredOperation, pInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCopyMicromapToMemoryEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT* pInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCopyMicromapToMemoryEXT\n"; - } + Timer timer("vkCopyMicromapToMemoryEXT"); VkResult result = device_dispatch_table(device)->CopyMicromapToMemoryEXT(device, deferredOperation, pInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT* pInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCopyMemoryToMicromapEXT\n"; - } + Timer timer("vkCopyMemoryToMicromapEXT"); VkResult result = device_dispatch_table(device)->CopyMemoryToMicromapEXT(device, deferredOperation, pInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, size_t dataSize, void* pData, size_t stride) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkWriteMicromapsPropertiesEXT\n"; - } + Timer timer("vkWriteMicromapsPropertiesEXT"); VkResult result = device_dispatch_table(device)->WriteMicromapsPropertiesEXT(device, micromapCount, pMicromaps, queryType, dataSize, pData, stride); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT* pInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdCopyMicromapEXT\n"; - } + Timer timer("vkCmdCopyMicromapEXT"); device_dispatch_table(commandBuffer)->CmdCopyMicromapEXT(commandBuffer, pInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyMicromapToMemoryEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT* pInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdCopyMicromapToMemoryEXT\n"; - } + Timer timer("vkCmdCopyMicromapToMemoryEXT"); device_dispatch_table(commandBuffer)->CmdCopyMicromapToMemoryEXT(commandBuffer, pInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT* pInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdCopyMemoryToMicromapEXT\n"; - } + Timer timer("vkCmdCopyMemoryToMicromapEXT"); device_dispatch_table(commandBuffer)->CmdCopyMemoryToMicromapEXT(commandBuffer, pInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdWriteMicromapsPropertiesEXT(VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdWriteMicromapsPropertiesEXT\n"; - } + Timer timer("vkCmdWriteMicromapsPropertiesEXT"); device_dispatch_table(commandBuffer)->CmdWriteMicromapsPropertiesEXT(commandBuffer, micromapCount, pMicromaps, queryType, queryPool, firstQuery); } template VKAPI_ATTR void VKAPI_CALL vkGetDeviceMicromapCompatibilityEXT(VkDevice device, const VkMicromapVersionInfoEXT* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDeviceMicromapCompatibilityEXT\n"; - } + Timer timer("vkGetDeviceMicromapCompatibilityEXT"); device_dispatch_table(device)->GetDeviceMicromapCompatibilityEXT(device, pVersionInfo, pCompatibility); } template VKAPI_ATTR void VKAPI_CALL vkGetMicromapBuildSizesEXT(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT* pBuildInfo, VkMicromapBuildSizesInfoEXT* pSizeInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetMicromapBuildSizesEXT\n"; - } + Timer timer("vkGetMicromapBuildSizesEXT"); device_dispatch_table(device)->GetMicromapBuildSizesEXT(device, buildType, pBuildInfo, pSizeInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdDrawClusterHUAWEI(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdDrawClusterHUAWEI\n"; - } + Timer timer("vkCmdDrawClusterHUAWEI"); device_dispatch_table(commandBuffer)->CmdDrawClusterHUAWEI(commandBuffer, groupCountX, groupCountY, groupCountZ); } template VKAPI_ATTR void VKAPI_CALL vkCmdDrawClusterIndirectHUAWEI(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdDrawClusterIndirectHUAWEI\n"; - } + Timer timer("vkCmdDrawClusterIndirectHUAWEI"); device_dispatch_table(commandBuffer)->CmdDrawClusterIndirectHUAWEI(commandBuffer, buffer, offset); } template VKAPI_ATTR void VKAPI_CALL vkSetDeviceMemoryPriorityEXT(VkDevice device, VkDeviceMemory memory, float priority) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkSetDeviceMemoryPriorityEXT\n"; - } + Timer timer("vkSetDeviceMemoryPriorityEXT"); device_dispatch_table(device)->SetDeviceMemoryPriorityEXT(device, memory, priority); } template VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutHostMappingInfoVALVE(VkDevice device, const VkDescriptorSetBindingReferenceVALVE* pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDescriptorSetLayoutHostMappingInfoVALVE\n"; - } + Timer timer("vkGetDescriptorSetLayoutHostMappingInfoVALVE"); device_dispatch_table(device)->GetDescriptorSetLayoutHostMappingInfoVALVE(device, pBindingReference, pHostMapping); } template VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetHostMappingVALVE(VkDevice device, VkDescriptorSet descriptorSet, void** ppData) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDescriptorSetHostMappingVALVE\n"; - } + Timer timer("vkGetDescriptorSetHostMappingVALVE"); device_dispatch_table(device)->GetDescriptorSetHostMappingVALVE(device, descriptorSet, ppData); } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdCopyMemoryIndirectNV\n"; - } + Timer timer("vkCmdCopyMemoryIndirectNV"); device_dispatch_table(commandBuffer)->CmdCopyMemoryIndirectNV(commandBuffer, copyBufferAddress, copyCount, stride); } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToImageIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VkImage dstImage, VkImageLayout dstImageLayout, const VkImageSubresourceLayers* pImageSubresources) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdCopyMemoryToImageIndirectNV\n"; - } + Timer timer("vkCmdCopyMemoryToImageIndirectNV"); device_dispatch_table(commandBuffer)->CmdCopyMemoryToImageIndirectNV(commandBuffer, copyBufferAddress, copyCount, stride, dstImage, dstImageLayout, pImageSubresources); } template VKAPI_ATTR void VKAPI_CALL vkCmdDecompressMemoryNV(VkCommandBuffer commandBuffer, uint32_t decompressRegionCount, const VkDecompressMemoryRegionNV* pDecompressMemoryRegions) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdDecompressMemoryNV\n"; - } + Timer timer("vkCmdDecompressMemoryNV"); device_dispatch_table(commandBuffer)->CmdDecompressMemoryNV(commandBuffer, decompressRegionCount, pDecompressMemoryRegions); } template VKAPI_ATTR void VKAPI_CALL vkCmdDecompressMemoryIndirectCountNV(VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t stride) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdDecompressMemoryIndirectCountNV\n"; - } + Timer timer("vkCmdDecompressMemoryIndirectCountNV"); device_dispatch_table(commandBuffer)->CmdDecompressMemoryIndirectCountNV(commandBuffer, indirectCommandsAddress, indirectCommandsCountAddress, stride); } template VKAPI_ATTR void VKAPI_CALL vkGetPipelineIndirectMemoryRequirementsNV(VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo, VkMemoryRequirements2* pMemoryRequirements) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPipelineIndirectMemoryRequirementsNV\n"; - } + Timer timer("vkGetPipelineIndirectMemoryRequirementsNV"); device_dispatch_table(device)->GetPipelineIndirectMemoryRequirementsNV(device, pCreateInfo, pMemoryRequirements); } template VKAPI_ATTR void VKAPI_CALL vkCmdUpdatePipelineIndirectBufferNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdUpdatePipelineIndirectBufferNV\n"; - } + Timer timer("vkCmdUpdatePipelineIndirectBufferNV"); device_dispatch_table(commandBuffer)->CmdUpdatePipelineIndirectBufferNV(commandBuffer, pipelineBindPoint, pipeline); } template VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetPipelineIndirectDeviceAddressNV(VkDevice device, const VkPipelineIndirectDeviceAddressInfoNV* pInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPipelineIndirectDeviceAddressNV\n"; - } + Timer timer("vkGetPipelineIndirectDeviceAddressNV"); VkDeviceAddress result = device_dispatch_table(device)->GetPipelineIndirectDeviceAddressNV(device, pInfo); return result; } #if defined(VK_USE_PLATFORM_OHOS) template VKAPI_ATTR VkResult VKAPI_CALL vkGetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer, VkNativeBufferPropertiesOHOS* pProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetNativeBufferPropertiesOHOS\n"; - } + Timer timer("vkGetNativeBufferPropertiesOHOS"); VkResult result = device_dispatch_table(device)->GetNativeBufferPropertiesOHOS(device, buffer, pProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, struct OH_NativeBuffer** pBuffer) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetMemoryNativeBufferOHOS\n"; - } + Timer timer("vkGetMemoryNativeBufferOHOS"); VkResult result = device_dispatch_table(device)->GetMemoryNativeBufferOHOS(device, pInfo, pBuffer); return result; } #endif // VK_USE_PLATFORM_OHOS template VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClampEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetDepthClampEnableEXT\n"; - } + Timer timer("vkCmdSetDepthClampEnableEXT"); device_dispatch_table(commandBuffer)->CmdSetDepthClampEnableEXT(commandBuffer, depthClampEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetPolygonModeEXT(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetPolygonModeEXT\n"; - } + Timer timer("vkCmdSetPolygonModeEXT"); device_dispatch_table(commandBuffer)->CmdSetPolygonModeEXT(commandBuffer, polygonMode); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizationSamplesEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetRasterizationSamplesEXT\n"; - } + Timer timer("vkCmdSetRasterizationSamplesEXT"); device_dispatch_table(commandBuffer)->CmdSetRasterizationSamplesEXT(commandBuffer, rasterizationSamples); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleMaskEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask* pSampleMask) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetSampleMaskEXT\n"; - } + Timer timer("vkCmdSetSampleMaskEXT"); device_dispatch_table(commandBuffer)->CmdSetSampleMaskEXT(commandBuffer, samples, pSampleMask); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetAlphaToCoverageEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetAlphaToCoverageEnableEXT\n"; - } + Timer timer("vkCmdSetAlphaToCoverageEnableEXT"); device_dispatch_table(commandBuffer)->CmdSetAlphaToCoverageEnableEXT(commandBuffer, alphaToCoverageEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetAlphaToOneEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetAlphaToOneEnableEXT\n"; - } + Timer timer("vkCmdSetAlphaToOneEnableEXT"); device_dispatch_table(commandBuffer)->CmdSetAlphaToOneEnableEXT(commandBuffer, alphaToOneEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetLogicOpEnableEXT(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetLogicOpEnableEXT\n"; - } + Timer timer("vkCmdSetLogicOpEnableEXT"); device_dispatch_table(commandBuffer)->CmdSetLogicOpEnableEXT(commandBuffer, logicOpEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetColorBlendEnableEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32* pColorBlendEnables) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetColorBlendEnableEXT\n"; - } + Timer timer("vkCmdSetColorBlendEnableEXT"); device_dispatch_table(commandBuffer)->CmdSetColorBlendEnableEXT(commandBuffer, firstAttachment, attachmentCount, pColorBlendEnables); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetColorBlendEquationEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT* pColorBlendEquations) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetColorBlendEquationEXT\n"; - } + Timer timer("vkCmdSetColorBlendEquationEXT"); device_dispatch_table(commandBuffer)->CmdSetColorBlendEquationEXT(commandBuffer, firstAttachment, attachmentCount, pColorBlendEquations); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetColorWriteMaskEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags* pColorWriteMasks) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetColorWriteMaskEXT\n"; - } + Timer timer("vkCmdSetColorWriteMaskEXT"); device_dispatch_table(commandBuffer)->CmdSetColorWriteMaskEXT(commandBuffer, firstAttachment, attachmentCount, pColorWriteMasks); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetTessellationDomainOriginEXT(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetTessellationDomainOriginEXT\n"; - } + Timer timer("vkCmdSetTessellationDomainOriginEXT"); device_dispatch_table(commandBuffer)->CmdSetTessellationDomainOriginEXT(commandBuffer, domainOrigin); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizationStreamEXT(VkCommandBuffer commandBuffer, uint32_t rasterizationStream) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetRasterizationStreamEXT\n"; - } + Timer timer("vkCmdSetRasterizationStreamEXT"); device_dispatch_table(commandBuffer)->CmdSetRasterizationStreamEXT(commandBuffer, rasterizationStream); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetConservativeRasterizationModeEXT(VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetConservativeRasterizationModeEXT\n"; - } + Timer timer("vkCmdSetConservativeRasterizationModeEXT"); device_dispatch_table(commandBuffer)->CmdSetConservativeRasterizationModeEXT(commandBuffer, conservativeRasterizationMode); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetExtraPrimitiveOverestimationSizeEXT(VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetExtraPrimitiveOverestimationSizeEXT\n"; - } + Timer timer("vkCmdSetExtraPrimitiveOverestimationSizeEXT"); device_dispatch_table(commandBuffer)->CmdSetExtraPrimitiveOverestimationSizeEXT(commandBuffer, extraPrimitiveOverestimationSize); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClipEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetDepthClipEnableEXT\n"; - } + Timer timer("vkCmdSetDepthClipEnableEXT"); device_dispatch_table(commandBuffer)->CmdSetDepthClipEnableEXT(commandBuffer, depthClipEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEnableEXT(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetSampleLocationsEnableEXT\n"; - } + Timer timer("vkCmdSetSampleLocationsEnableEXT"); device_dispatch_table(commandBuffer)->CmdSetSampleLocationsEnableEXT(commandBuffer, sampleLocationsEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetColorBlendAdvancedEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT* pColorBlendAdvanced) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetColorBlendAdvancedEXT\n"; - } + Timer timer("vkCmdSetColorBlendAdvancedEXT"); device_dispatch_table(commandBuffer)->CmdSetColorBlendAdvancedEXT(commandBuffer, firstAttachment, attachmentCount, pColorBlendAdvanced); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetProvokingVertexModeEXT(VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetProvokingVertexModeEXT\n"; - } + Timer timer("vkCmdSetProvokingVertexModeEXT"); device_dispatch_table(commandBuffer)->CmdSetProvokingVertexModeEXT(commandBuffer, provokingVertexMode); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetLineRasterizationModeEXT(VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetLineRasterizationModeEXT\n"; - } + Timer timer("vkCmdSetLineRasterizationModeEXT"); device_dispatch_table(commandBuffer)->CmdSetLineRasterizationModeEXT(commandBuffer, lineRasterizationMode); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetLineStippleEnableEXT\n"; - } + Timer timer("vkCmdSetLineStippleEnableEXT"); device_dispatch_table(commandBuffer)->CmdSetLineStippleEnableEXT(commandBuffer, stippledLineEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClipNegativeOneToOneEXT(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetDepthClipNegativeOneToOneEXT\n"; - } + Timer timer("vkCmdSetDepthClipNegativeOneToOneEXT"); device_dispatch_table(commandBuffer)->CmdSetDepthClipNegativeOneToOneEXT(commandBuffer, negativeOneToOne); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingEnableNV(VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetViewportWScalingEnableNV\n"; - } + Timer timer("vkCmdSetViewportWScalingEnableNV"); device_dispatch_table(commandBuffer)->CmdSetViewportWScalingEnableNV(commandBuffer, viewportWScalingEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportSwizzleNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV* pViewportSwizzles) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetViewportSwizzleNV\n"; - } + Timer timer("vkCmdSetViewportSwizzleNV"); device_dispatch_table(commandBuffer)->CmdSetViewportSwizzleNV(commandBuffer, firstViewport, viewportCount, pViewportSwizzles); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageToColorEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetCoverageToColorEnableNV\n"; - } + Timer timer("vkCmdSetCoverageToColorEnableNV"); device_dispatch_table(commandBuffer)->CmdSetCoverageToColorEnableNV(commandBuffer, coverageToColorEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageToColorLocationNV(VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetCoverageToColorLocationNV\n"; - } + Timer timer("vkCmdSetCoverageToColorLocationNV"); device_dispatch_table(commandBuffer)->CmdSetCoverageToColorLocationNV(commandBuffer, coverageToColorLocation); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageModulationModeNV(VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetCoverageModulationModeNV\n"; - } + Timer timer("vkCmdSetCoverageModulationModeNV"); device_dispatch_table(commandBuffer)->CmdSetCoverageModulationModeNV(commandBuffer, coverageModulationMode); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageModulationTableEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetCoverageModulationTableEnableNV\n"; - } + Timer timer("vkCmdSetCoverageModulationTableEnableNV"); device_dispatch_table(commandBuffer)->CmdSetCoverageModulationTableEnableNV(commandBuffer, coverageModulationTableEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageModulationTableNV(VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float* pCoverageModulationTable) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetCoverageModulationTableNV\n"; - } + Timer timer("vkCmdSetCoverageModulationTableNV"); device_dispatch_table(commandBuffer)->CmdSetCoverageModulationTableNV(commandBuffer, coverageModulationTableCount, pCoverageModulationTable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetShadingRateImageEnableNV(VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetShadingRateImageEnableNV\n"; - } + Timer timer("vkCmdSetShadingRateImageEnableNV"); device_dispatch_table(commandBuffer)->CmdSetShadingRateImageEnableNV(commandBuffer, shadingRateImageEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetRepresentativeFragmentTestEnableNV(VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetRepresentativeFragmentTestEnableNV\n"; - } + Timer timer("vkCmdSetRepresentativeFragmentTestEnableNV"); device_dispatch_table(commandBuffer)->CmdSetRepresentativeFragmentTestEnableNV(commandBuffer, representativeFragmentTestEnable); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageReductionModeNV(VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetCoverageReductionModeNV\n"; - } + Timer timer("vkCmdSetCoverageReductionModeNV"); device_dispatch_table(commandBuffer)->CmdSetCoverageReductionModeNV(commandBuffer, coverageReductionMode); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateTensorARM(VkDevice device, const VkTensorCreateInfoARM* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkTensorARM* pTensor) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateTensorARM\n"; - } + Timer timer("vkCreateTensorARM"); VkResult result = device_dispatch_table(device)->CreateTensorARM(device, pCreateInfo, pAllocator, pTensor); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyTensorARM(VkDevice device, VkTensorARM tensor, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyTensorARM\n"; - } + Timer timer("vkDestroyTensorARM"); device_dispatch_table(device)->DestroyTensorARM(device, tensor, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateTensorViewARM(VkDevice device, const VkTensorViewCreateInfoARM* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkTensorViewARM* pView) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateTensorViewARM\n"; - } + Timer timer("vkCreateTensorViewARM"); VkResult result = device_dispatch_table(device)->CreateTensorViewARM(device, pCreateInfo, pAllocator, pView); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyTensorViewARM(VkDevice device, VkTensorViewARM tensorView, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyTensorViewARM\n"; - } + Timer timer("vkDestroyTensorViewARM"); device_dispatch_table(device)->DestroyTensorViewARM(device, tensorView, pAllocator); } template VKAPI_ATTR void VKAPI_CALL vkGetTensorMemoryRequirementsARM(VkDevice device, const VkTensorMemoryRequirementsInfoARM* pInfo, VkMemoryRequirements2* pMemoryRequirements) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetTensorMemoryRequirementsARM\n"; - } + Timer timer("vkGetTensorMemoryRequirementsARM"); device_dispatch_table(device)->GetTensorMemoryRequirementsARM(device, pInfo, pMemoryRequirements); } template VKAPI_ATTR VkResult VKAPI_CALL vkBindTensorMemoryARM(VkDevice device, uint32_t bindInfoCount, const VkBindTensorMemoryInfoARM* pBindInfos) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkBindTensorMemoryARM\n"; - } + Timer timer("vkBindTensorMemoryARM"); VkResult result = device_dispatch_table(device)->BindTensorMemoryARM(device, bindInfoCount, pBindInfos); return result; } template VKAPI_ATTR void VKAPI_CALL vkGetDeviceTensorMemoryRequirementsARM(VkDevice device, const VkDeviceTensorMemoryRequirementsARM* pInfo, VkMemoryRequirements2* pMemoryRequirements) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDeviceTensorMemoryRequirementsARM\n"; - } + Timer timer("vkGetDeviceTensorMemoryRequirementsARM"); device_dispatch_table(device)->GetDeviceTensorMemoryRequirementsARM(device, pInfo, pMemoryRequirements); } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyTensorARM(VkCommandBuffer commandBuffer, const VkCopyTensorInfoARM* pCopyTensorInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdCopyTensorARM\n"; - } + Timer timer("vkCmdCopyTensorARM"); device_dispatch_table(commandBuffer)->CmdCopyTensorARM(commandBuffer, pCopyTensorInfo); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetTensorOpaqueCaptureDescriptorDataARM(VkDevice device, const VkTensorCaptureDescriptorDataInfoARM* pInfo, void* pData) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetTensorOpaqueCaptureDescriptorDataARM\n"; - } + Timer timer("vkGetTensorOpaqueCaptureDescriptorDataARM"); VkResult result = device_dispatch_table(device)->GetTensorOpaqueCaptureDescriptorDataARM(device, pInfo, pData); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetTensorViewOpaqueCaptureDescriptorDataARM(VkDevice device, const VkTensorViewCaptureDescriptorDataInfoARM* pInfo, void* pData) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetTensorViewOpaqueCaptureDescriptorDataARM\n"; - } + Timer timer("vkGetTensorViewOpaqueCaptureDescriptorDataARM"); VkResult result = device_dispatch_table(device)->GetTensorViewOpaqueCaptureDescriptorDataARM(device, pInfo, pData); return result; } template VKAPI_ATTR void VKAPI_CALL vkGetShaderModuleIdentifierEXT(VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT* pIdentifier) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetShaderModuleIdentifierEXT\n"; - } + Timer timer("vkGetShaderModuleIdentifierEXT"); device_dispatch_table(device)->GetShaderModuleIdentifierEXT(device, shaderModule, pIdentifier); } template VKAPI_ATTR void VKAPI_CALL vkGetShaderModuleCreateInfoIdentifierEXT(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModuleIdentifierEXT* pIdentifier) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetShaderModuleCreateInfoIdentifierEXT\n"; - } + Timer timer("vkGetShaderModuleCreateInfoIdentifierEXT"); device_dispatch_table(device)->GetShaderModuleCreateInfoIdentifierEXT(device, pCreateInfo, pIdentifier); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateOpticalFlowSessionNV(VkDevice device, const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkOpticalFlowSessionNV* pSession) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateOpticalFlowSessionNV\n"; - } + Timer timer("vkCreateOpticalFlowSessionNV"); VkResult result = device_dispatch_table(device)->CreateOpticalFlowSessionNV(device, pCreateInfo, pAllocator, pSession); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyOpticalFlowSessionNV(VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyOpticalFlowSessionNV\n"; - } + Timer timer("vkDestroyOpticalFlowSessionNV"); device_dispatch_table(device)->DestroyOpticalFlowSessionNV(device, session, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkBindOpticalFlowSessionImageNV(VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkBindOpticalFlowSessionImageNV\n"; - } + Timer timer("vkBindOpticalFlowSessionImageNV"); VkResult result = device_dispatch_table(device)->BindOpticalFlowSessionImageNV(device, session, bindingPoint, view, layout); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdOpticalFlowExecuteNV(VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV* pExecuteInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdOpticalFlowExecuteNV\n"; - } + Timer timer("vkCmdOpticalFlowExecuteNV"); device_dispatch_table(commandBuffer)->CmdOpticalFlowExecuteNV(commandBuffer, session, pExecuteInfo); } template VKAPI_ATTR void VKAPI_CALL vkAntiLagUpdateAMD(VkDevice device, const VkAntiLagDataAMD* pData) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkAntiLagUpdateAMD\n"; - } + Timer timer("vkAntiLagUpdateAMD"); device_dispatch_table(device)->AntiLagUpdateAMD(device, pData); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateShadersEXT(VkDevice device, uint32_t createInfoCount, const VkShaderCreateInfoEXT* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkShaderEXT* pShaders) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateShadersEXT\n"; - } + Timer timer("vkCreateShadersEXT"); VkResult result = device_dispatch_table(device)->CreateShadersEXT(device, createInfoCount, pCreateInfos, pAllocator, pShaders); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyShaderEXT(VkDevice device, VkShaderEXT shader, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyShaderEXT\n"; - } + Timer timer("vkDestroyShaderEXT"); device_dispatch_table(device)->DestroyShaderEXT(device, shader, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetShaderBinaryDataEXT(VkDevice device, VkShaderEXT shader, size_t* pDataSize, void* pData) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetShaderBinaryDataEXT\n"; - } + Timer timer("vkGetShaderBinaryDataEXT"); VkResult result = device_dispatch_table(device)->GetShaderBinaryDataEXT(device, shader, pDataSize, pData); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdBindShadersEXT(VkCommandBuffer commandBuffer, uint32_t stageCount, const VkShaderStageFlagBits* pStages, const VkShaderEXT* pShaders) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBindShadersEXT\n"; - } + Timer timer("vkCmdBindShadersEXT"); device_dispatch_table(commandBuffer)->CmdBindShadersEXT(commandBuffer, stageCount, pStages, pShaders); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClampRangeEXT(VkCommandBuffer commandBuffer, VkDepthClampModeEXT depthClampMode, const VkDepthClampRangeEXT* pDepthClampRange) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetDepthClampRangeEXT\n"; - } + Timer timer("vkCmdSetDepthClampRangeEXT"); device_dispatch_table(commandBuffer)->CmdSetDepthClampRangeEXT(commandBuffer, depthClampMode, pDepthClampRange); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetFramebufferTilePropertiesQCOM(VkDevice device, VkFramebuffer framebuffer, uint32_t* pPropertiesCount, VkTilePropertiesQCOM* pProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetFramebufferTilePropertiesQCOM\n"; - } + Timer timer("vkGetFramebufferTilePropertiesQCOM"); VkResult result = device_dispatch_table(device)->GetFramebufferTilePropertiesQCOM(device, framebuffer, pPropertiesCount, pProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDynamicRenderingTilePropertiesQCOM\n"; - } + Timer timer("vkGetDynamicRenderingTilePropertiesQCOM"); VkResult result = device_dispatch_table(device)->GetDynamicRenderingTilePropertiesQCOM(device, pRenderingInfo, pProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkConvertCooperativeVectorMatrixNV(VkDevice device, const VkConvertCooperativeVectorMatrixInfoNV* pInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkConvertCooperativeVectorMatrixNV\n"; - } + Timer timer("vkConvertCooperativeVectorMatrixNV"); VkResult result = device_dispatch_table(device)->ConvertCooperativeVectorMatrixNV(device, pInfo); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdConvertCooperativeVectorMatrixNV(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkConvertCooperativeVectorMatrixInfoNV* pInfos) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdConvertCooperativeVectorMatrixNV\n"; - } + Timer timer("vkCmdConvertCooperativeVectorMatrixNV"); device_dispatch_table(commandBuffer)->CmdConvertCooperativeVectorMatrixNV(commandBuffer, infoCount, pInfos); } template VKAPI_ATTR VkResult VKAPI_CALL vkSetLatencySleepModeNV(VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepModeInfoNV* pSleepModeInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkSetLatencySleepModeNV\n"; - } + Timer timer("vkSetLatencySleepModeNV"); VkResult result = device_dispatch_table(device)->SetLatencySleepModeNV(device, swapchain, pSleepModeInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkLatencySleepNV(VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepInfoNV* pSleepInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkLatencySleepNV\n"; - } + Timer timer("vkLatencySleepNV"); VkResult result = device_dispatch_table(device)->LatencySleepNV(device, swapchain, pSleepInfo); return result; } template VKAPI_ATTR void VKAPI_CALL vkSetLatencyMarkerNV(VkDevice device, VkSwapchainKHR swapchain, const VkSetLatencyMarkerInfoNV* pLatencyMarkerInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkSetLatencyMarkerNV\n"; - } + Timer timer("vkSetLatencyMarkerNV"); device_dispatch_table(device)->SetLatencyMarkerNV(device, swapchain, pLatencyMarkerInfo); } template VKAPI_ATTR void VKAPI_CALL vkGetLatencyTimingsNV(VkDevice device, VkSwapchainKHR swapchain, VkGetLatencyMarkerInfoNV* pLatencyMarkerInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetLatencyTimingsNV\n"; - } + Timer timer("vkGetLatencyTimingsNV"); device_dispatch_table(device)->GetLatencyTimingsNV(device, swapchain, pLatencyMarkerInfo); } template VKAPI_ATTR void VKAPI_CALL vkQueueNotifyOutOfBandNV(VkQueue queue, const VkOutOfBandQueueTypeInfoNV* pQueueTypeInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkQueueNotifyOutOfBandNV\n"; - } + Timer timer("vkQueueNotifyOutOfBandNV"); device_dispatch_table(queue)->QueueNotifyOutOfBandNV(queue, pQueueTypeInfo); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateDataGraphPipelinesARM(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkDataGraphPipelineCreateInfoARM* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateDataGraphPipelinesARM\n"; - } + Timer timer("vkCreateDataGraphPipelinesARM"); VkResult result = device_dispatch_table(device)->CreateDataGraphPipelinesARM(device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateDataGraphPipelineSessionARM(VkDevice device, const VkDataGraphPipelineSessionCreateInfoARM* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDataGraphPipelineSessionARM* pSession) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateDataGraphPipelineSessionARM\n"; - } + Timer timer("vkCreateDataGraphPipelineSessionARM"); VkResult result = device_dispatch_table(device)->CreateDataGraphPipelineSessionARM(device, pCreateInfo, pAllocator, pSession); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetDataGraphPipelineSessionBindPointRequirementsARM(VkDevice device, const VkDataGraphPipelineSessionBindPointRequirementsInfoARM* pInfo, uint32_t* pBindPointRequirementCount, VkDataGraphPipelineSessionBindPointRequirementARM* pBindPointRequirements) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDataGraphPipelineSessionBindPointRequirementsARM\n"; - } + Timer timer("vkGetDataGraphPipelineSessionBindPointRequirementsARM"); VkResult result = device_dispatch_table(device)->GetDataGraphPipelineSessionBindPointRequirementsARM(device, pInfo, pBindPointRequirementCount, pBindPointRequirements); return result; } template VKAPI_ATTR void VKAPI_CALL vkGetDataGraphPipelineSessionMemoryRequirementsARM(VkDevice device, const VkDataGraphPipelineSessionMemoryRequirementsInfoARM* pInfo, VkMemoryRequirements2* pMemoryRequirements) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDataGraphPipelineSessionMemoryRequirementsARM\n"; - } + Timer timer("vkGetDataGraphPipelineSessionMemoryRequirementsARM"); device_dispatch_table(device)->GetDataGraphPipelineSessionMemoryRequirementsARM(device, pInfo, pMemoryRequirements); } template VKAPI_ATTR VkResult VKAPI_CALL vkBindDataGraphPipelineSessionMemoryARM(VkDevice device, uint32_t bindInfoCount, const VkBindDataGraphPipelineSessionMemoryInfoARM* pBindInfos) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkBindDataGraphPipelineSessionMemoryARM\n"; - } + Timer timer("vkBindDataGraphPipelineSessionMemoryARM"); VkResult result = device_dispatch_table(device)->BindDataGraphPipelineSessionMemoryARM(device, bindInfoCount, pBindInfos); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyDataGraphPipelineSessionARM(VkDevice device, VkDataGraphPipelineSessionARM session, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyDataGraphPipelineSessionARM\n"; - } + Timer timer("vkDestroyDataGraphPipelineSessionARM"); device_dispatch_table(device)->DestroyDataGraphPipelineSessionARM(device, session, pAllocator); } template VKAPI_ATTR void VKAPI_CALL vkCmdDispatchDataGraphARM(VkCommandBuffer commandBuffer, VkDataGraphPipelineSessionARM session, const VkDataGraphPipelineDispatchInfoARM* pInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdDispatchDataGraphARM\n"; - } + Timer timer("vkCmdDispatchDataGraphARM"); device_dispatch_table(commandBuffer)->CmdDispatchDataGraphARM(commandBuffer, session, pInfo); } template VKAPI_ATTR VkResult VKAPI_CALL vkGetDataGraphPipelineAvailablePropertiesARM(VkDevice device, const VkDataGraphPipelineInfoARM* pPipelineInfo, uint32_t* pPropertiesCount, VkDataGraphPipelinePropertyARM* pProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDataGraphPipelineAvailablePropertiesARM\n"; - } + Timer timer("vkGetDataGraphPipelineAvailablePropertiesARM"); VkResult result = device_dispatch_table(device)->GetDataGraphPipelineAvailablePropertiesARM(device, pPipelineInfo, pPropertiesCount, pProperties); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetDataGraphPipelinePropertiesARM(VkDevice device, const VkDataGraphPipelineInfoARM* pPipelineInfo, uint32_t propertiesCount, VkDataGraphPipelinePropertyQueryResultARM* pProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDataGraphPipelinePropertiesARM\n"; - } + Timer timer("vkGetDataGraphPipelinePropertiesARM"); VkResult result = device_dispatch_table(device)->GetDataGraphPipelinePropertiesARM(device, pPipelineInfo, propertiesCount, pProperties); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdSetAttachmentFeedbackLoopEnableEXT(VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetAttachmentFeedbackLoopEnableEXT\n"; - } + Timer timer("vkCmdSetAttachmentFeedbackLoopEnableEXT"); device_dispatch_table(commandBuffer)->CmdSetAttachmentFeedbackLoopEnableEXT(commandBuffer, aspectMask); } #if defined(VK_USE_PLATFORM_SCREEN_QNX) template VKAPI_ATTR VkResult VKAPI_CALL vkGetScreenBufferPropertiesQNX(VkDevice device, const struct _screen_buffer* buffer, VkScreenBufferPropertiesQNX* pProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetScreenBufferPropertiesQNX\n"; - } + Timer timer("vkGetScreenBufferPropertiesQNX"); VkResult result = device_dispatch_table(device)->GetScreenBufferPropertiesQNX(device, buffer, pProperties); return result; } #endif // VK_USE_PLATFORM_SCREEN_QNX template VKAPI_ATTR void VKAPI_CALL vkCmdBindTileMemoryQCOM(VkCommandBuffer commandBuffer, const VkTileMemoryBindInfoQCOM* pTileMemoryBindInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBindTileMemoryQCOM\n"; - } + Timer timer("vkCmdBindTileMemoryQCOM"); device_dispatch_table(commandBuffer)->CmdBindTileMemoryQCOM(commandBuffer, pTileMemoryBindInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdDecompressMemoryEXT(VkCommandBuffer commandBuffer, const VkDecompressMemoryInfoEXT* pDecompressMemoryInfoEXT) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdDecompressMemoryEXT\n"; - } + Timer timer("vkCmdDecompressMemoryEXT"); device_dispatch_table(commandBuffer)->CmdDecompressMemoryEXT(commandBuffer, pDecompressMemoryInfoEXT); } template VKAPI_ATTR void VKAPI_CALL vkCmdDecompressMemoryIndirectCountEXT(VkCommandBuffer commandBuffer, VkMemoryDecompressionMethodFlagsEXT decompressionMethod, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t maxDecompressionCount, uint32_t stride) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdDecompressMemoryIndirectCountEXT\n"; - } + Timer timer("vkCmdDecompressMemoryIndirectCountEXT"); device_dispatch_table(commandBuffer)->CmdDecompressMemoryIndirectCountEXT(commandBuffer, decompressionMethod, indirectCommandsAddress, indirectCommandsCountAddress, maxDecompressionCount, stride); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateExternalComputeQueueNV(VkDevice device, const VkExternalComputeQueueCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkExternalComputeQueueNV* pExternalQueue) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateExternalComputeQueueNV\n"; - } + Timer timer("vkCreateExternalComputeQueueNV"); VkResult result = device_dispatch_table(device)->CreateExternalComputeQueueNV(device, pCreateInfo, pAllocator, pExternalQueue); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyExternalComputeQueueNV(VkDevice device, VkExternalComputeQueueNV externalQueue, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyExternalComputeQueueNV\n"; - } + Timer timer("vkDestroyExternalComputeQueueNV"); device_dispatch_table(device)->DestroyExternalComputeQueueNV(device, externalQueue, pAllocator); } template VKAPI_ATTR void VKAPI_CALL vkGetExternalComputeQueueDataNV(VkExternalComputeQueueNV externalQueue, VkExternalComputeQueueDataParamsNV* params, void* pData) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetExternalComputeQueueDataNV\n"; - } + Timer timer("vkGetExternalComputeQueueDataNV"); device_dispatch_table(externalQueue)->GetExternalComputeQueueDataNV(externalQueue, params, pData); } template VKAPI_ATTR void VKAPI_CALL vkGetClusterAccelerationStructureBuildSizesNV(VkDevice device, const VkClusterAccelerationStructureInputInfoNV* pInfo, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetClusterAccelerationStructureBuildSizesNV\n"; - } + Timer timer("vkGetClusterAccelerationStructureBuildSizesNV"); device_dispatch_table(device)->GetClusterAccelerationStructureBuildSizesNV(device, pInfo, pSizeInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdBuildClusterAccelerationStructureIndirectNV(VkCommandBuffer commandBuffer, const VkClusterAccelerationStructureCommandsInfoNV* pCommandInfos) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBuildClusterAccelerationStructureIndirectNV\n"; - } + Timer timer("vkCmdBuildClusterAccelerationStructureIndirectNV"); device_dispatch_table(commandBuffer)->CmdBuildClusterAccelerationStructureIndirectNV(commandBuffer, pCommandInfos); } template VKAPI_ATTR void VKAPI_CALL vkGetPartitionedAccelerationStructuresBuildSizesNV(VkDevice device, const VkPartitionedAccelerationStructureInstancesInputNV* pInfo, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetPartitionedAccelerationStructuresBuildSizesNV\n"; - } + Timer timer("vkGetPartitionedAccelerationStructuresBuildSizesNV"); device_dispatch_table(device)->GetPartitionedAccelerationStructuresBuildSizesNV(device, pInfo, pSizeInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdBuildPartitionedAccelerationStructuresNV(VkCommandBuffer commandBuffer, const VkBuildPartitionedAccelerationStructureInfoNV* pBuildInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBuildPartitionedAccelerationStructuresNV\n"; - } + Timer timer("vkCmdBuildPartitionedAccelerationStructuresNV"); device_dispatch_table(commandBuffer)->CmdBuildPartitionedAccelerationStructuresNV(commandBuffer, pBuildInfo); } template VKAPI_ATTR void VKAPI_CALL vkGetGeneratedCommandsMemoryRequirementsEXT(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoEXT* pInfo, VkMemoryRequirements2* pMemoryRequirements) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetGeneratedCommandsMemoryRequirementsEXT\n"; - } + Timer timer("vkGetGeneratedCommandsMemoryRequirementsEXT"); device_dispatch_table(device)->GetGeneratedCommandsMemoryRequirementsEXT(device, pInfo, pMemoryRequirements); } template VKAPI_ATTR void VKAPI_CALL vkCmdPreprocessGeneratedCommandsEXT(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo, VkCommandBuffer stateCommandBuffer) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdPreprocessGeneratedCommandsEXT\n"; - } + Timer timer("vkCmdPreprocessGeneratedCommandsEXT"); device_dispatch_table(commandBuffer)->CmdPreprocessGeneratedCommandsEXT(commandBuffer, pGeneratedCommandsInfo, stateCommandBuffer); } template VKAPI_ATTR void VKAPI_CALL vkCmdExecuteGeneratedCommandsEXT(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdExecuteGeneratedCommandsEXT\n"; - } + Timer timer("vkCmdExecuteGeneratedCommandsEXT"); device_dispatch_table(commandBuffer)->CmdExecuteGeneratedCommandsEXT(commandBuffer, isPreprocessed, pGeneratedCommandsInfo); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutEXT(VkDevice device, const VkIndirectCommandsLayoutCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutEXT* pIndirectCommandsLayout) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateIndirectCommandsLayoutEXT\n"; - } + Timer timer("vkCreateIndirectCommandsLayoutEXT"); VkResult result = device_dispatch_table(device)->CreateIndirectCommandsLayoutEXT(device, pCreateInfo, pAllocator, pIndirectCommandsLayout); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutEXT(VkDevice device, VkIndirectCommandsLayoutEXT indirectCommandsLayout, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyIndirectCommandsLayoutEXT\n"; - } + Timer timer("vkDestroyIndirectCommandsLayoutEXT"); device_dispatch_table(device)->DestroyIndirectCommandsLayoutEXT(device, indirectCommandsLayout, pAllocator); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectExecutionSetEXT(VkDevice device, const VkIndirectExecutionSetCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectExecutionSetEXT* pIndirectExecutionSet) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateIndirectExecutionSetEXT\n"; - } + Timer timer("vkCreateIndirectExecutionSetEXT"); VkResult result = device_dispatch_table(device)->CreateIndirectExecutionSetEXT(device, pCreateInfo, pAllocator, pIndirectExecutionSet); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectExecutionSetEXT(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyIndirectExecutionSetEXT\n"; - } + Timer timer("vkDestroyIndirectExecutionSetEXT"); device_dispatch_table(device)->DestroyIndirectExecutionSetEXT(device, indirectExecutionSet, pAllocator); } template VKAPI_ATTR void VKAPI_CALL vkUpdateIndirectExecutionSetPipelineEXT(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, const VkWriteIndirectExecutionSetPipelineEXT* pExecutionSetWrites) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkUpdateIndirectExecutionSetPipelineEXT\n"; - } + Timer timer("vkUpdateIndirectExecutionSetPipelineEXT"); device_dispatch_table(device)->UpdateIndirectExecutionSetPipelineEXT(device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites); } template VKAPI_ATTR void VKAPI_CALL vkUpdateIndirectExecutionSetShaderEXT(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, const VkWriteIndirectExecutionSetShaderEXT* pExecutionSetWrites) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkUpdateIndirectExecutionSetShaderEXT\n"; - } + Timer timer("vkUpdateIndirectExecutionSetShaderEXT"); device_dispatch_table(device)->UpdateIndirectExecutionSetShaderEXT(device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites); } #if defined(VK_USE_PLATFORM_METAL_EXT) template VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryMetalHandleEXT(VkDevice device, const VkMemoryGetMetalHandleInfoEXT* pGetMetalHandleInfo, void** pHandle) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetMemoryMetalHandleEXT\n"; - } + Timer timer("vkGetMemoryMetalHandleEXT"); VkResult result = device_dispatch_table(device)->GetMemoryMetalHandleEXT(device, pGetMetalHandleInfo, pHandle); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryMetalHandlePropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHandle, VkMemoryMetalHandlePropertiesEXT* pMemoryMetalHandleProperties) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetMemoryMetalHandlePropertiesEXT\n"; - } + Timer timer("vkGetMemoryMetalHandlePropertiesEXT"); VkResult result = device_dispatch_table(device)->GetMemoryMetalHandlePropertiesEXT(device, handleType, pHandle, pMemoryMetalHandleProperties); return result; } #endif // VK_USE_PLATFORM_METAL_EXT template VKAPI_ATTR void VKAPI_CALL vkCmdEndRendering2EXT(VkCommandBuffer commandBuffer, const VkRenderingEndInfoKHR* pRenderingEndInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdEndRendering2EXT\n"; - } + Timer timer("vkCmdEndRendering2EXT"); device_dispatch_table(commandBuffer)->CmdEndRendering2EXT(commandBuffer, pRenderingEndInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdBeginCustomResolveEXT(VkCommandBuffer commandBuffer, const VkBeginCustomResolveInfoEXT* pBeginCustomResolveInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBeginCustomResolveEXT\n"; - } + Timer timer("vkCmdBeginCustomResolveEXT"); device_dispatch_table(commandBuffer)->CmdBeginCustomResolveEXT(commandBuffer, pBeginCustomResolveInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdSetComputeOccupancyPriorityNV(VkCommandBuffer commandBuffer, const VkComputeOccupancyPriorityParametersNV* pParameters) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetComputeOccupancyPriorityNV\n"; - } + Timer timer("vkCmdSetComputeOccupancyPriorityNV"); device_dispatch_table(commandBuffer)->CmdSetComputeOccupancyPriorityNV(commandBuffer, pParameters); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateAccelerationStructureKHR\n"; - } + Timer timer("vkCreateAccelerationStructureKHR"); VkResult result = device_dispatch_table(device)->CreateAccelerationStructureKHR(device, pCreateInfo, pAllocator, pAccelerationStructure); return result; } template VKAPI_ATTR void VKAPI_CALL vkDestroyAccelerationStructureKHR(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks* pAllocator) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkDestroyAccelerationStructureKHR\n"; - } + Timer timer("vkDestroyAccelerationStructureKHR"); device_dispatch_table(device)->DestroyAccelerationStructureKHR(device, accelerationStructure, pAllocator); } template VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructuresKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBuildAccelerationStructuresKHR\n"; - } + Timer timer("vkCmdBuildAccelerationStructuresKHR"); device_dispatch_table(commandBuffer)->CmdBuildAccelerationStructuresKHR(commandBuffer, infoCount, pInfos, ppBuildRangeInfos); } template VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructuresIndirectKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkDeviceAddress* pIndirectDeviceAddresses, const uint32_t* pIndirectStrides, const uint32_t* const* ppMaxPrimitiveCounts) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdBuildAccelerationStructuresIndirectKHR\n"; - } + Timer timer("vkCmdBuildAccelerationStructuresIndirectKHR"); device_dispatch_table(commandBuffer)->CmdBuildAccelerationStructuresIndirectKHR(commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts); } template VKAPI_ATTR VkResult VKAPI_CALL vkBuildAccelerationStructuresKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkBuildAccelerationStructuresKHR\n"; - } + Timer timer("vkBuildAccelerationStructuresKHR"); VkResult result = device_dispatch_table(device)->BuildAccelerationStructuresKHR(device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCopyAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR* pInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCopyAccelerationStructureKHR\n"; - } + Timer timer("vkCopyAccelerationStructureKHR"); VkResult result = device_dispatch_table(device)->CopyAccelerationStructureKHR(device, deferredOperation, pInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCopyAccelerationStructureToMemoryKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCopyAccelerationStructureToMemoryKHR\n"; - } + Timer timer("vkCopyAccelerationStructureToMemoryKHR"); VkResult result = device_dispatch_table(device)->CopyAccelerationStructureToMemoryKHR(device, deferredOperation, pInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCopyMemoryToAccelerationStructureKHR\n"; - } + Timer timer("vkCopyMemoryToAccelerationStructureKHR"); VkResult result = device_dispatch_table(device)->CopyMemoryToAccelerationStructureKHR(device, deferredOperation, pInfo); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkWriteAccelerationStructuresPropertiesKHR(VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, size_t dataSize, void* pData, size_t stride) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkWriteAccelerationStructuresPropertiesKHR\n"; - } + Timer timer("vkWriteAccelerationStructuresPropertiesKHR"); VkResult result = device_dispatch_table(device)->WriteAccelerationStructuresPropertiesKHR(device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR* pInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdCopyAccelerationStructureKHR\n"; - } + Timer timer("vkCmdCopyAccelerationStructureKHR"); device_dispatch_table(commandBuffer)->CmdCopyAccelerationStructureKHR(commandBuffer, pInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureToMemoryKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdCopyAccelerationStructureToMemoryKHR\n"; - } + Timer timer("vkCmdCopyAccelerationStructureToMemoryKHR"); device_dispatch_table(commandBuffer)->CmdCopyAccelerationStructureToMemoryKHR(commandBuffer, pInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdCopyMemoryToAccelerationStructureKHR\n"; - } + Timer timer("vkCmdCopyMemoryToAccelerationStructureKHR"); device_dispatch_table(commandBuffer)->CmdCopyMemoryToAccelerationStructureKHR(commandBuffer, pInfo); } template VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetAccelerationStructureDeviceAddressKHR(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetAccelerationStructureDeviceAddressKHR\n"; - } + Timer timer("vkGetAccelerationStructureDeviceAddressKHR"); VkDeviceAddress result = device_dispatch_table(device)->GetAccelerationStructureDeviceAddressKHR(device, pInfo); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdWriteAccelerationStructuresPropertiesKHR(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdWriteAccelerationStructuresPropertiesKHR\n"; - } + Timer timer("vkCmdWriteAccelerationStructuresPropertiesKHR"); device_dispatch_table(commandBuffer)->CmdWriteAccelerationStructuresPropertiesKHR(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery); } template VKAPI_ATTR void VKAPI_CALL vkGetDeviceAccelerationStructureCompatibilityKHR(VkDevice device, const VkAccelerationStructureVersionInfoKHR* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetDeviceAccelerationStructureCompatibilityKHR\n"; - } + Timer timer("vkGetDeviceAccelerationStructureCompatibilityKHR"); device_dispatch_table(device)->GetDeviceAccelerationStructureCompatibilityKHR(device, pVersionInfo, pCompatibility); } template VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureBuildSizesKHR(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetAccelerationStructureBuildSizesKHR\n"; - } + Timer timer("vkGetAccelerationStructureBuildSizesKHR"); device_dispatch_table(device)->GetAccelerationStructureBuildSizesKHR(device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo); } template VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdTraceRaysKHR\n"; - } + Timer timer("vkCmdTraceRaysKHR"); device_dispatch_table(commandBuffer)->CmdTraceRaysKHR(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth); } template VKAPI_ATTR VkResult VKAPI_CALL vkCreateRayTracingPipelinesKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCreateRayTracingPipelinesKHR\n"; - } + Timer timer("vkCreateRayTracingPipelinesKHR"); VkResult result = device_dispatch_table(device)->CreateRayTracingPipelinesKHR(device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); return result; } template VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR\n"; - } + Timer timer("vkGetRayTracingCaptureReplayShaderGroupHandlesKHR"); VkResult result = device_dispatch_table(device)->GetRayTracingCaptureReplayShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount, dataSize, pData); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysIndirectKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdTraceRaysIndirectKHR\n"; - } + Timer timer("vkCmdTraceRaysIndirectKHR"); device_dispatch_table(commandBuffer)->CmdTraceRaysIndirectKHR(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress); } template VKAPI_ATTR VkDeviceSize VKAPI_CALL vkGetRayTracingShaderGroupStackSizeKHR(VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkGetRayTracingShaderGroupStackSizeKHR\n"; - } + Timer timer("vkGetRayTracingShaderGroupStackSizeKHR"); VkDeviceSize result = device_dispatch_table(device)->GetRayTracingShaderGroupStackSizeKHR(device, pipeline, group, groupShader); return result; } template VKAPI_ATTR void VKAPI_CALL vkCmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdSetRayTracingPipelineStackSizeKHR\n"; - } + Timer timer("vkCmdSetRayTracingPipelineStackSizeKHR"); device_dispatch_table(commandBuffer)->CmdSetRayTracingPipelineStackSizeKHR(commandBuffer, pipelineStackSize); } template VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksEXT(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdDrawMeshTasksEXT\n"; - } + Timer timer("vkCmdDrawMeshTasksEXT"); device_dispatch_table(commandBuffer)->CmdDrawMeshTasksEXT(commandBuffer, groupCountX, groupCountY, groupCountZ); } template VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectEXT(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdDrawMeshTasksIndirectEXT\n"; - } + Timer timer("vkCmdDrawMeshTasksIndirectEXT"); device_dispatch_table(commandBuffer)->CmdDrawMeshTasksIndirectEXT(commandBuffer, buffer, offset, drawCount, stride); } template VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectCountEXT(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - - if (ApiDumpInstance::current().shouldDumpOutput()) { - ApiDumpInstance::current().settings().stream() << "vkCmdDrawMeshTasksIndirectCountEXT\n"; - } + Timer timer("vkCmdDrawMeshTasksIndirectCountEXT"); device_dispatch_table(commandBuffer)->CmdDrawMeshTasksIndirectCountEXT(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); } diff --git a/scripts/generators/api_dump_generator.py b/scripts/generators/api_dump_generator.py index 5197ae1b14..7f4a84b725 100644 --- a/scripts/generators/api_dump_generator.py +++ b/scripts/generators/api_dump_generator.py @@ -369,6 +369,7 @@ def generate_copyright(self): def generate_dispatch_codegen(self): self.write('''#include "api_dump_handwritten_functions.h" +#include "timer.h" // Autogen instance functions ''') @@ -381,12 +382,7 @@ def generate_dispatch_codegen(self): self.write('template') self.write(f'VKAPI_ATTR {command.returnType} VKAPI_CALL {command.name}({command_param_declaration_text(command)})') self.write('{') - if command.name not in BLOCKING_API_CALLS: - self.write(f''' - std::lock_guard lg(ApiDumpInstance::current().outputMutex()); - if (ApiDumpInstance::current().shouldDumpOutput()) {{ - ApiDumpInstance::current().settings().stream() << "{command.name}\\n"; - }}''') + self.write(f'Timer timer("{command.name}");') if command.name == 'vkGetPhysicalDeviceToolPropertiesEXT': self.write(''' @@ -410,11 +406,7 @@ def generate_dispatch_codegen(self): return_str = f'{command.returnType} result = ' if command.returnType != 'void' else '' self.write(f'{return_str}instance_dispatch_table({command.params[0].name})->{command.name[2:]}({command_param_usage_text(command)});') - if command.name in BLOCKING_API_CALLS: - self.write('std::lock_guard lg(ApiDumpInstance::current().outputMutex());') - self.write(f'''if (ApiDumpInstance::current().shouldDumpOutput()) {{ - ApiDumpInstance::current().settings().stream() << "{command.name}\\n"; - }}''') + if command.name in TRACKED_STATE: self.write(TRACKED_STATE[command.name]) @@ -454,22 +446,11 @@ def generate_dispatch_codegen(self): self.write(f'VKAPI_ATTR {command.returnType} VKAPI_CALL {command.name}({command_param_declaration_text(command)})') self.write('{') - if command.name not in BLOCKING_API_CALLS: - self.write('std::lock_guard lg(ApiDumpInstance::current().outputMutex());') - if command.name in ['vkDebugMarkerSetObjectNameEXT', 'vkSetDebugUtilsObjectNameEXT']: - self.write('ApiDumpInstance::current().update_object_name_map(pNameInfo);') - self.write(f''' - if (ApiDumpInstance::current().shouldDumpOutput()) {{ - ApiDumpInstance::current().settings().stream() << "{command.name}\\n"; - }}''') + self.write(f'Timer timer("{command.name}");') return_str = f'{command.returnType} result = ' if command.returnType != 'void' else '' self.write(f'{return_str}device_dispatch_table({command.params[0].name})->{command.name[2:]}({command_param_usage_text(command)});') - if command.name in BLOCKING_API_CALLS: - self.write('std::lock_guard lg(ApiDumpInstance::current().outputMutex());') - self.write(f'''if (ApiDumpInstance::current().shouldDumpOutput()) {{ - ApiDumpInstance::current().settings().stream() << "{command.name}\\n"; - }}''') + if command.name in TRACKED_STATE: self.write('' + TRACKED_STATE[command.name]) From 131252646a182bdaa27c7276bf7e59677cf31a7e Mon Sep 17 00:00:00 2001 From: Emre Kultursay Date: Thu, 26 Feb 2026 10:59:57 -0800 Subject: [PATCH 06/14] Update CPUTiming layer to use the generated style similar to api_dump --- layersvt/CMakeLists.txt | 24 +- layersvt/cputiming.cpp | 538 - layersvt/cputiming_handwritten_dispatch.cpp | 86 + layersvt/cputiming_handwritten_functions.h | 131 + layersvt/generated/api_dump_dispatch.h | 1 + layersvt/generated/api_dump_implementation.h | 12 + layersvt/generated/cputiming_dispatch.h | 5986 ++ layersvt/generated/cputiming_implementation.h | 64943 ++++++++++++++++ layersvt/json/VkLayer_CPUTiming.json.in | 2 +- scripts/generate_source.py | 8 + scripts/generators/api_dump_generator.py | 17 +- 11 files changed, 71204 insertions(+), 544 deletions(-) delete mode 100644 layersvt/cputiming.cpp create mode 100644 layersvt/cputiming_handwritten_dispatch.cpp create mode 100644 layersvt/cputiming_handwritten_functions.h create mode 100644 layersvt/generated/cputiming_dispatch.h create mode 100644 layersvt/generated/cputiming_implementation.h diff --git a/layersvt/CMakeLists.txt b/layersvt/CMakeLists.txt index 24f8dd8f70..7754490a51 100644 --- a/layersvt/CMakeLists.txt +++ b/layersvt/CMakeLists.txt @@ -122,11 +122,33 @@ if(BUILD_CPUTIMING) add_library(VkLayer_CPUTiming MODULE) set_target_properties(VkLayer_CPUTiming PROPERTIES FOLDER "layers/cputiming") target_sources(VkLayer_CPUTiming PRIVATE - cputiming.cpp + cputiming_handwritten_dispatch.cpp + generated/cputiming_dispatch.h + generated/cputiming_implementation.h + generated/cputiming_implementation.h + api_dump.h + cputiming_handwritten_functions.h + ../scripts/generators/api_dump_generator.py vk_layer_table.cpp vk_layer_table.h json/VkLayer_CPUTiming.json.in ) + + if(CMAKE_SYSTEM_NAME MATCHES "Linux|BSD|DragonFly|GNU") + if (BUILD_WSI_XCB_SUPPORT) + target_compile_definitions(VkLayer_CPUTiming PRIVATE VK_USE_PLATFORM_XLIB_KHR) + endif() + + if (BUILD_WSI_WAYLAND_SUPPORT) + target_compile_definitions(VkLayer_CPUTiming PRIVATE VK_USE_PLATFORM_WAYLAND_KHR) + endif() + endif() + + target_compile_definitions(VkLayer_CPUTiming PRIVATE VK_ENABLE_BETA_EXTENSIONS) + + if (VT_CODEGEN) + add_dependencies(VkLayer_CPUTiming vt_codegen_as_needed) + endif() endif() if (BUILD_TESTS AND NOT RUN_ON_GITHUB) diff --git a/layersvt/cputiming.cpp b/layersvt/cputiming.cpp deleted file mode 100644 index 228a952c2b..0000000000 --- a/layersvt/cputiming.cpp +++ /dev/null @@ -1,538 +0,0 @@ -/* - * Copyright (C) 2015-2021 Valve Corporation - * Copyright (C) 2015-2021 LunarG, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Author: Cody Northrop - * Author: David Pinedo - * Author: Jon Ashburn - * Author: Tony Barbour - */ -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include "vk_layer_table.h" - -#ifdef ANDROID -#include -#include -#endif - -namespace cputiming { - -#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0])) - -std::mutex globalLock; - -VkuLayerSettingSet globalLayerSettingSet = VK_NULL_HANDLE; - -// unordered map: associates Vulkan dispatchable objects to a dispatch table -typedef struct { - VkuDeviceDispatchTable *device_dispatch_table; - PFN_vkSetDeviceLoaderData pfn_dev_init; -} DispatchMapStruct; -static std::unordered_map dispatchMap; - -// unordered map: associates a device with per device info - -// wsi capability -// set of queues created for this device -// queue to queueFamilyIndex map -// physical device -struct DeviceMapStruct { - bool wsi_enabled; - std::set queues; - std::unordered_map queueIndexMap; - VkPhysicalDevice physicalDevice; -}; -static std::unordered_map deviceMap; - -// unordered map: associates a physical device with an instance -typedef struct { - VkInstance instance; -} PhysDeviceMapStruct; -static std::unordered_map physDeviceMap; - -static void LogMessage(const char* format, ...) { - va_list args; - va_start(args, format); -#ifdef ANDROID - __android_log_vprint(ANDROID_LOG_INFO, "CPUTiming", format, args); -#else - vprintf(format, args); - printf("\n"); -#endif - va_end(args); -} - -static DispatchMapStruct *get_dispatch_info(VkDevice dev) { - auto it = dispatchMap.find(dev); - if (it == dispatchMap.end()) - return NULL; - else - return it->second; -} - -static DeviceMapStruct *get_device_info(VkDevice dev) { - auto it = deviceMap.find(dev); - if (it == deviceMap.end()) - return NULL; - else - return it->second; -} - -static void init_cputiming(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator) { - std::lock_guard lg(globalLock); - // keeping layer settings structure if we ever need it, but currently unused - // logic simplified -} - -static void shutdown_cputiming() { - // cleanup if needed -} - -VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, - VkInstance *pInstance) { - LogMessage("CreateInstance"); - VkLayerInstanceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO); - - assert(chain_info->u.pLayerInfo); - PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr; - assert(fpGetInstanceProcAddr); - PFN_vkCreateInstance fpCreateInstance = (PFN_vkCreateInstance)fpGetInstanceProcAddr(VK_NULL_HANDLE, "vkCreateInstance"); - if (fpCreateInstance == NULL) { - return VK_ERROR_INITIALIZATION_FAILED; - } - - // Advance the link info for the next element on the chain - chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext; - - VkResult result = fpCreateInstance(pCreateInfo, pAllocator, pInstance); - if (result != VK_SUCCESS) return result; - - initInstanceTable(*pInstance, fpGetInstanceProcAddr); - init_cputiming(pCreateInfo, pAllocator); - - return result; -} - -VKAPI_ATTR void VKAPI_CALL DestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) { - LogMessage("DestroyInstance"); - shutdown_cputiming(); - - VkuInstanceDispatchTable *pTable = instance_dispatch_table(instance); - pTable->DestroyInstance(instance, pAllocator); -} - -static void createDeviceRegisterExtensions(const VkDeviceCreateInfo *pCreateInfo, VkDevice device) { - uint32_t i; - DispatchMapStruct *dispMap = get_dispatch_info(device); - DeviceMapStruct *devMap = get_device_info(device); - VkuDeviceDispatchTable *pDisp = dispMap->device_dispatch_table; - PFN_vkGetDeviceProcAddr gpa = pDisp->GetDeviceProcAddr; - pDisp->CreateSwapchainKHR = (PFN_vkCreateSwapchainKHR)gpa(device, "vkCreateSwapchainKHR"); - pDisp->GetSwapchainImagesKHR = (PFN_vkGetSwapchainImagesKHR)gpa(device, "vkGetSwapchainImagesKHR"); - pDisp->AcquireNextImageKHR = (PFN_vkAcquireNextImageKHR)gpa(device, "vkAcquireNextImageKHR"); - pDisp->QueuePresentKHR = (PFN_vkQueuePresentKHR)gpa(device, "vkQueuePresentKHR"); - devMap->wsi_enabled = false; - for (i = 0; i < pCreateInfo->enabledExtensionCount; i++) { - if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_SWAPCHAIN_EXTENSION_NAME) == 0) devMap->wsi_enabled = true; - } -} - -VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) { - LogMessage("CreateDevice"); - VkLayerDeviceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO); - - assert(chain_info->u.pLayerInfo); - PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr; - PFN_vkGetDeviceProcAddr fpGetDeviceProcAddr = chain_info->u.pLayerInfo->pfnNextGetDeviceProcAddr; - VkInstance instance = physDeviceMap[gpu].instance; - PFN_vkCreateDevice fpCreateDevice = (PFN_vkCreateDevice)fpGetInstanceProcAddr(instance, "vkCreateDevice"); - if (fpCreateDevice == NULL) { - return VK_ERROR_INITIALIZATION_FAILED; - } - - // Advance the link info for the next element on the chain - chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext; - - VkResult result = fpCreateDevice(gpu, pCreateInfo, pAllocator, pDevice); - if (result != VK_SUCCESS) { - return result; - } - - assert(deviceMap.find(*pDevice) == deviceMap.end()); - DeviceMapStruct *deviceMapElem = new DeviceMapStruct; - deviceMap[*pDevice] = deviceMapElem; - assert(dispatchMap.find(*pDevice) == dispatchMap.end()); - DispatchMapStruct *dispatchMapElem = new DispatchMapStruct; - dispatchMap[*pDevice] = dispatchMapElem; - - // Setup device dispatch table - dispatchMapElem->device_dispatch_table = new VkuDeviceDispatchTable; - vkuInitDeviceDispatchTable(*pDevice, dispatchMapElem->device_dispatch_table, fpGetDeviceProcAddr); - - createDeviceRegisterExtensions(pCreateInfo, *pDevice); - // Create a mapping from a device to a physicalDevice - deviceMapElem->physicalDevice = gpu; - - // store the loader callback for initializing created dispatchable objects - chain_info = get_chain_info(pCreateInfo, VK_LOADER_DATA_CALLBACK); - if (chain_info) { - dispatchMapElem->pfn_dev_init = chain_info->u.pfnSetDeviceLoaderData; - } else { - dispatchMapElem->pfn_dev_init = NULL; - } - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, - VkPhysicalDevice *pPhysicalDevices) { - LogMessage("EnumeratePhysicalDevices"); - VkResult result; - - VkuInstanceDispatchTable *pTable = instance_dispatch_table(instance); - result = pTable->EnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices); - if (result == VK_SUCCESS && *pPhysicalDeviceCount > 0 && pPhysicalDevices) { - for (uint32_t i = 0; i < *pPhysicalDeviceCount; i++) { - // Create a mapping from a physicalDevice to an instance - physDeviceMap[pPhysicalDevices[i]].instance = instance; - } - } - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, - VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties) { - LogMessage("EnumeratePhysicalDeviceGroups"); - VkResult result; - VkuInstanceDispatchTable *pTable = instance_dispatch_table(instance); - result = pTable->EnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); - if (result == VK_SUCCESS && *pPhysicalDeviceGroupCount > 0 && pPhysicalDeviceGroupProperties) { - for (uint32_t i = 0; i < *pPhysicalDeviceGroupCount; i++) { - for (uint32_t j = 0; j < pPhysicalDeviceGroupProperties[i].physicalDeviceCount; j++) { - // Create a mapping from each physicalDevice to an instance - physDeviceMap[pPhysicalDeviceGroupProperties[i].physicalDevices[j]].instance = instance; - } - } - } - return VK_SUCCESS; -} - -VKAPI_ATTR void VKAPI_CALL DestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) { - LogMessage("DestroyDevice"); - DispatchMapStruct *dispMap = get_dispatch_info(device); - DeviceMapStruct *devMap = get_device_info(device); - assert(dispMap); - assert(devMap); - VkuDeviceDispatchTable *pDisp = dispMap->device_dispatch_table; - pDisp->DestroyDevice(device, pAllocator); - - std::lock_guard lg(globalLock); - delete pDisp; - delete dispMap; - delete devMap; - - deviceMap.erase(device); - dispatchMap.erase(device); -} - -VKAPI_ATTR void VKAPI_CALL GetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue) { - LogMessage("GetDeviceQueue"); - DispatchMapStruct *dispMap = get_dispatch_info(device); - assert(dispMap); - VkuDeviceDispatchTable *pDisp = dispMap->device_dispatch_table; - pDisp->GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue); - - std::lock_guard lg(globalLock); - - // Add this queue to deviceMap[device].queues, and queueFamilyIndex to deviceMap[device].queueIndexMap - if (deviceMap.find(device) != deviceMap.end()) { - deviceMap[device]->queues.emplace(*pQueue); - - if (deviceMap[device]->queueIndexMap.find(*pQueue) != deviceMap[device]->queueIndexMap.end()) - deviceMap[device]->queueIndexMap.erase(*pQueue); - deviceMap[device]->queueIndexMap.emplace(*pQueue, queueFamilyIndex); - } - - // queues are dispatchable objects. - // Create dispatchMap entry with this queue as its key. - // Copy the device dispatch table to the new dispatch table. - VkDevice que = static_cast(static_cast(*pQueue)); - dispatchMap[que] = dispMap; -} - -VKAPI_ATTR void VKAPI_CALL GetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue) { - LogMessage("GetDeviceQueue2"); - if (pQueueInfo) GetDeviceQueue(device, pQueueInfo->queueFamilyIndex, pQueueInfo->queueIndex, pQueue); -} - -VKAPI_ATTR VkResult VKAPI_CALL CreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain) { - LogMessage("CreateSwapchainKHR"); - DispatchMapStruct *dispMap = get_dispatch_info(device); - assert(dispMap); - VkuDeviceDispatchTable *pDisp = dispMap->device_dispatch_table; - - VkResult result = pDisp->CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain); - return result; -} - -VKAPI_ATTR void DestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator) { - LogMessage("DestroySwapchainKHR"); - DispatchMapStruct *dispMap = get_dispatch_info(device); - assert(dispMap); - VkuDeviceDispatchTable *pDisp = dispMap->device_dispatch_table; - pDisp->DestroySwapchainKHR(device, swapchain, pAllocator); -} - -VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pCount, - VkImage *pSwapchainImages) { - LogMessage("GetSwapchainImagesKHR"); - DispatchMapStruct *dispMap = get_dispatch_info(device); - assert(dispMap); - VkuDeviceDispatchTable *pDisp = dispMap->device_dispatch_table; - VkResult result = pDisp->GetSwapchainImagesKHR(device, swapchain, pCount, pSwapchainImages); - return result; -} - -VKAPI_ATTR VkResult VKAPI_CALL QueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo) { - LogMessage("QueuePresentKHR"); - DispatchMapStruct *dispMap = get_dispatch_info((VkDevice)queue); - VkuDeviceDispatchTable *pDisp = dispMap->device_dispatch_table; - assert(dispMap); - VkResult result = pDisp->QueuePresentKHR(queue, pPresentInfo); - return result; -} - -static const VkLayerProperties global_layer = { - "CPUTiming", // layerName - VK_MAKE_VERSION(1, 0, 0), // specVersion - 1, // implementationVersion - "Layer: CPUTiming", // description -}; - -VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceLayerProperties(uint32_t *pCount, VkLayerProperties *pProperties) { - return util_GetLayerProperties(1, &global_layer, pCount, pProperties); -} - -VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount, - VkLayerProperties *pProperties) { - return util_GetLayerProperties(1, &global_layer, pCount, pProperties); -} - -VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount, - VkExtensionProperties *pProperties) { - if (pLayerName && !strcmp(pLayerName, global_layer.layerName)) return util_GetExtensionProperties(0, NULL, pCount, pProperties); - - return VK_ERROR_LAYER_NOT_PRESENT; -} - -VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName, - uint32_t *pCount, VkExtensionProperties *pProperties) { - if (pLayerName && !strcmp(pLayerName, global_layer.layerName)) return util_GetExtensionProperties(0, NULL, pCount, pProperties); - - assert(physicalDevice); - - VkuInstanceDispatchTable *pTable = instance_dispatch_table(physicalDevice); - return pTable->EnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pCount, pProperties); -} - -VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceToolPropertiesEXT(VkPhysicalDevice physicalDevice, uint32_t *pToolCount, - VkPhysicalDeviceToolPropertiesEXT *pToolProperties) { - LogMessage("GetPhysicalDeviceToolPropertiesEXT"); - static const VkPhysicalDeviceToolPropertiesEXT cputiming_layer_tool_props = { - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT, - nullptr, - "CPUTiming Layer", - "1", - VK_TOOL_PURPOSE_PROFILING_BIT_EXT | VK_TOOL_PURPOSE_TRACING_BIT_EXT | VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT_EXT, - "The VK_LAYER_CPUTiming layer prints API calls.", - "VK_LAYER_CPUTiming"}; - - auto original_pToolProperties = pToolProperties; - if (pToolProperties != nullptr) { - *pToolProperties = cputiming_layer_tool_props; - pToolProperties = ((*pToolCount > 1) ? &pToolProperties[1] : nullptr); - (*pToolCount)--; - } - - VkuInstanceDispatchTable *pInstanceTable = instance_dispatch_table(physicalDevice); - VkResult result = pInstanceTable->GetPhysicalDeviceToolPropertiesEXT(physicalDevice, pToolCount, pToolProperties); - - if (original_pToolProperties != nullptr) { - pToolProperties = original_pToolProperties; - } - - (*pToolCount)++; - - return result; -} - -static PFN_vkVoidFunction intercept_core_instance_command(const char *name); - -static PFN_vkVoidFunction intercept_core_device_command(const char *name); - -static PFN_vkVoidFunction intercept_khr_swapchain_command(const char *name, VkDevice dev); - -VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(VkDevice dev, const char *funcName) { - PFN_vkVoidFunction proc = intercept_core_device_command(funcName); - if (proc) return proc; - - if (dev == NULL) { - return NULL; - } - - proc = intercept_khr_swapchain_command(funcName, dev); - if (proc) return proc; - - DispatchMapStruct *dispMap = get_dispatch_info(dev); - assert(dispMap); - VkuDeviceDispatchTable *pDisp = dispMap->device_dispatch_table; - - if (pDisp->GetDeviceProcAddr == NULL) return NULL; - return pDisp->GetDeviceProcAddr(dev, funcName); -} - -VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(VkInstance instance, const char *funcName) { - PFN_vkVoidFunction proc = intercept_core_instance_command(funcName); - if (proc) return proc; - - assert(instance); - - proc = intercept_core_device_command(funcName); - if (!proc) proc = intercept_khr_swapchain_command(funcName, VK_NULL_HANDLE); - if (proc) return proc; - - VkuInstanceDispatchTable *pTable = instance_dispatch_table(instance); - if (pTable->GetInstanceProcAddr == NULL) return NULL; - return pTable->GetInstanceProcAddr(instance, funcName); -} - -static PFN_vkVoidFunction intercept_core_instance_command(const char *name) { - static const struct { - const char *name; - PFN_vkVoidFunction proc; - } core_instance_commands[] = { - {"vkGetInstanceProcAddr", reinterpret_cast(GetInstanceProcAddr)}, - {"vkCreateInstance", reinterpret_cast(CreateInstance)}, - {"vkDestroyInstance", reinterpret_cast(DestroyInstance)}, - {"vkCreateDevice", reinterpret_cast(CreateDevice)}, - {"vkEnumeratePhysicalDevices", reinterpret_cast(EnumeratePhysicalDevices)}, - {"vkEnumeratePhysicalDeviceGroups", reinterpret_cast(EnumeratePhysicalDeviceGroups)}, - {"vkEnumerateInstanceLayerProperties", reinterpret_cast(EnumerateInstanceLayerProperties)}, - {"vkEnumerateDeviceLayerProperties", reinterpret_cast(EnumerateDeviceLayerProperties)}, - {"vkEnumerateInstanceExtensionProperties", reinterpret_cast(EnumerateInstanceExtensionProperties)}, - {"vkEnumerateDeviceExtensionProperties", reinterpret_cast(EnumerateDeviceExtensionProperties)}, - {"vkGetPhysicalDeviceToolPropertiesEXT", reinterpret_cast(GetPhysicalDeviceToolPropertiesEXT)}}; - - for (size_t i = 0; i < ARRAY_SIZE(core_instance_commands); i++) { - if (!strcmp(core_instance_commands[i].name, name)) return core_instance_commands[i].proc; - } - - return nullptr; -} - -static PFN_vkVoidFunction intercept_core_device_command(const char *name) { - static const struct { - const char *name; - PFN_vkVoidFunction proc; - } core_device_commands[] = { - {"vkGetDeviceProcAddr", reinterpret_cast(GetDeviceProcAddr)}, - {"vkGetDeviceQueue", reinterpret_cast(GetDeviceQueue)}, - {"vkGetDeviceQueue2", reinterpret_cast(GetDeviceQueue2)}, - {"vkDestroyDevice", reinterpret_cast(DestroyDevice)}, - }; - - for (size_t i = 0; i < ARRAY_SIZE(core_device_commands); i++) { - if (!strcmp(core_device_commands[i].name, name)) return core_device_commands[i].proc; - } - - return nullptr; -} - -static PFN_vkVoidFunction intercept_khr_swapchain_command(const char *name, VkDevice dev) { - static const struct { - const char *name; - PFN_vkVoidFunction proc; - } khr_swapchain_commands[] = { - {"vkCreateSwapchainKHR", reinterpret_cast(CreateSwapchainKHR)}, - {"vkDestroySwapchainKHR", reinterpret_cast(DestroySwapchainKHR)}, - {"vkQueuePresentKHR", reinterpret_cast(QueuePresentKHR)}, - }; - - if (dev) { - DeviceMapStruct *devMap = get_device_info(dev); - if (!devMap->wsi_enabled) return nullptr; - } - - for (size_t i = 0; i < ARRAY_SIZE(khr_swapchain_commands); i++) { - if (!strcmp(khr_swapchain_commands[i].name, name)) return khr_swapchain_commands[i].proc; - } - - return nullptr; -} - -} // namespace cputiming - -#if defined(__GNUC__) && __GNUC__ >= 4 -#define EXPORT_FUNCTION __attribute__((visibility("default"))) -#elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590) -#define EXPORT_FUNCTION __attribute__((visibility("default"))) -#else -#define EXPORT_FUNCTION -#endif - -EXPORT_FUNCTION VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(uint32_t *pCount, - VkLayerProperties *pProperties) { - return cputiming::EnumerateInstanceLayerProperties(pCount, pProperties); -} - -EXPORT_FUNCTION VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount, - VkLayerProperties *pProperties) { - assert(physicalDevice == VK_NULL_HANDLE); - return cputiming::EnumerateDeviceLayerProperties(VK_NULL_HANDLE, pCount, pProperties); -} - -EXPORT_FUNCTION VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount, - VkExtensionProperties *pProperties) { - return cputiming::EnumerateInstanceExtensionProperties(pLayerName, pCount, pProperties); -} - -EXPORT_FUNCTION VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, - const char *pLayerName, uint32_t *pCount, - VkExtensionProperties *pProperties) { - assert(physicalDevice == VK_NULL_HANDLE); - return cputiming::EnumerateDeviceExtensionProperties(VK_NULL_HANDLE, pLayerName, pCount, pProperties); -} - -EXPORT_FUNCTION VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice dev, const char *funcName) { - return cputiming::GetDeviceProcAddr(dev, funcName); -} - -EXPORT_FUNCTION VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance, const char *funcName) { - return cputiming::GetInstanceProcAddr(instance, funcName); -} diff --git a/layersvt/cputiming_handwritten_dispatch.cpp b/layersvt/cputiming_handwritten_dispatch.cpp new file mode 100644 index 0000000000..3b52859e2f --- /dev/null +++ b/layersvt/cputiming_handwritten_dispatch.cpp @@ -0,0 +1,86 @@ +/* Copyright (c) 2015-2023 The Khronos Group Inc. + * Copyright (c) 2015-2023 Valve Corporation + * Copyright (c) 2015-2023 LunarG, Inc. + * Copyright (C) 2015-2016 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * Author: Lenny Komow + * Author: Shannon McPherson + * Author: David Pinedo + * Author: Charles Giessen + */ + +// Implementation file for specifically implemented functions + +#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0])) + +#include "generated/cputiming_dispatch.h" + +extern "C" { + +EXPORT_FUNCTION VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance, const char* pName) { + PFN_vkVoidFunction instance_func = nullptr; + switch (ApiDumpInstance::current().settings().format()) { + case ApiDumpFormat::Text: + instance_func = api_dump_known_instance_functions(instance, pName); + break; + case ApiDumpFormat::Html: + instance_func = api_dump_known_instance_functions(instance, pName); + break; + case ApiDumpFormat::Json: + instance_func = api_dump_known_instance_functions(instance, pName); + break; + } + if (instance_func) return instance_func; + PFN_vkVoidFunction device_func = nullptr; + + switch (ApiDumpInstance::current().settings().format()) { + case ApiDumpFormat::Text: + device_func = api_dump_known_device_functions(NULL, pName); + break; + case ApiDumpFormat::Html: + device_func = api_dump_known_device_functions(NULL, pName); + break; + case ApiDumpFormat::Json: + device_func = api_dump_known_device_functions(NULL, pName); + break; + } + // Make sure that device functions queried through GIPA works + if (device_func) return device_func; + + // Haven't created an instance yet, exit now since there is no instance_dispatch_table + if (instance_dispatch_table(instance)->GetInstanceProcAddr == NULL) return nullptr; + return instance_dispatch_table(instance)->GetInstanceProcAddr(instance, pName); +} + +EXPORT_FUNCTION VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice device, const char* pName) { + PFN_vkVoidFunction device_func = nullptr; + switch (ApiDumpInstance::current().settings().format()) { + case ApiDumpFormat::Text: + device_func = api_dump_known_device_functions(device, pName); + break; + case ApiDumpFormat::Html: + device_func = api_dump_known_device_functions(device, pName); + break; + case ApiDumpFormat::Json: + device_func = api_dump_known_device_functions(device, pName); + break; + } + if (device_func) return device_func; + + // Haven't created a device yet, exit now since there is no device_dispatch_table + if (device_dispatch_table(device)->GetDeviceProcAddr == NULL) return nullptr; + return device_dispatch_table(device)->GetDeviceProcAddr(device, pName); +} +} diff --git a/layersvt/cputiming_handwritten_functions.h b/layersvt/cputiming_handwritten_functions.h new file mode 100644 index 0000000000..e97db7d969 --- /dev/null +++ b/layersvt/cputiming_handwritten_functions.h @@ -0,0 +1,131 @@ +/* Copyright (c) 2015-2023 The Khronos Group Inc. + * Copyright (c) 2015-2023 Valve Corporation + * Copyright (c) 2015-2023 LunarG, Inc. + * Copyright (C) 2015-2016 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * Author: Lenny Komow + * Author: Shannon McPherson + * Author: David Pinedo + * Author: Charles Giessen + */ + +// Implementation file for specifically implemented functions + +#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0])) + +#include "generated/cputiming_implementation.h" +#include "timer.h" + +extern "C" { + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, + VkInstance* pInstance) { + Timer timer("vkCreateInstance"); +#if defined(_WIN32) && defined(_CRTDBG_MODE_FILE) +#if !defined(NDEBUG) + _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE); + _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR); +#endif + // Avoid "Abort, Retry, Ignore" dialog boxes + _set_abort_behavior(0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT); + SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX); + _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE); + _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR); +#endif + + std::lock_guard lg(ApiDumpInstance::current().outputMutex()); + ApiDumpInstance::current().initLayerSettings(pCreateInfo, pAllocator); + + // Get the function pointer + VkLayerInstanceCreateInfo* chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO); + assert(chain_info->u.pLayerInfo != 0); + PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr; + assert(fpGetInstanceProcAddr != 0); + PFN_vkCreateInstance fpCreateInstance = (PFN_vkCreateInstance)fpGetInstanceProcAddr(NULL, "vkCreateInstance"); + if (fpCreateInstance == NULL) { + return VK_ERROR_INITIALIZATION_FAILED; + } + + // Call the function and create the dispatch table + chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext; + VkResult result = fpCreateInstance(pCreateInfo, pAllocator, pInstance); + if (result == VK_SUCCESS) { + initInstanceTable(*pInstance, fpGetInstanceProcAddr); + } + + return result; +} +} + +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) { + Timer timer("vkCreateDevice"); + std::lock_guard lg(ApiDumpInstance::current().outputMutex()); + + // Get the function pointer + VkLayerDeviceCreateInfo* chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO); + assert(chain_info->u.pLayerInfo != 0); + PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr; + PFN_vkGetDeviceProcAddr fpGetDeviceProcAddr = chain_info->u.pLayerInfo->pfnNextGetDeviceProcAddr; + VkInstance vk_instance = ApiDumpInstance::current().get_vk_instance(physicalDevice); + PFN_vkCreateDevice fpCreateDevice = (PFN_vkCreateDevice)fpGetInstanceProcAddr(vk_instance, "vkCreateDevice"); + if (fpCreateDevice == NULL) { + return VK_ERROR_INITIALIZATION_FAILED; + } + + // Call the function and create the dispatch table + chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext; + VkResult result = fpCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice); + if (result == VK_SUCCESS) { + initDeviceTable(*pDevice, fpGetDeviceProcAddr); + } + + return result; +} + +extern "C" { + +EXPORT_FUNCTION VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(const char* pLayerName, + uint32_t* pPropertyCount, + VkExtensionProperties* pProperties) { + return util_GetExtensionProperties(0, NULL, pPropertyCount, pProperties); +} + +EXPORT_FUNCTION VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, + VkLayerProperties* pProperties) { + static const VkLayerProperties layerProperties[] = {{ + "CPUTiming", + VK_MAKE_VERSION(1, 4, VK_HEADER_VERSION), // specVersion + VK_MAKE_VERSION(0, 2, 0), // implementationVersion + "layer: CPUTiming", + }}; + + return util_GetLayerProperties(ARRAY_SIZE(layerProperties), layerProperties, pPropertyCount, pProperties); +} + +EXPORT_FUNCTION VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkLayerProperties* pProperties) { + static const VkLayerProperties layerProperties[] = {{ + "CPUTiming", + VK_MAKE_VERSION(1, 4, VK_HEADER_VERSION), + VK_MAKE_VERSION(0, 2, 0), + "layer: CPUTiming", + }}; + + return util_GetLayerProperties(ARRAY_SIZE(layerProperties), layerProperties, pPropertyCount, pProperties); +} +} diff --git a/layersvt/generated/api_dump_dispatch.h b/layersvt/generated/api_dump_dispatch.h index 27a2575719..18fa3eff5c 100644 --- a/layersvt/generated/api_dump_dispatch.h +++ b/layersvt/generated/api_dump_dispatch.h @@ -22,6 +22,7 @@ */ #include "api_dump_handwritten_functions.h" + #include "timer.h" // Autogen instance functions diff --git a/layersvt/generated/api_dump_implementation.h b/layersvt/generated/api_dump_implementation.h index 6d391f38b5..938889861d 100644 --- a/layersvt/generated/api_dump_implementation.h +++ b/layersvt/generated/api_dump_implementation.h @@ -11442,10 +11442,12 @@ void dump_VkBufferUsageFlagBits(const VkBufferUsageFlagBits object, const ApiDum settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT"; is_first = false; } +#if defined(VK_ENABLE_BETA_EXTENSIONS) if (object & VK_BUFFER_USAGE_EXECUTION_GRAPH_SCRATCH_BIT_AMDX) { settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_EXECUTION_GRAPH_SCRATCH_BIT_AMDX"; is_first = false; } +#endif if (object & VK_BUFFER_USAGE_DESCRIPTOR_HEAP_BIT_EXT) { settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_DESCRIPTOR_HEAP_BIT_EXT"; is_first = false; @@ -11828,10 +11830,12 @@ void dump_VkPipelineCreateFlagBits(const VkPipelineCreateFlagBits object, const settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT"; is_first = false; } +#if defined(VK_ENABLE_BETA_EXTENSIONS) if (object & VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV) { settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV"; is_first = false; } +#endif if (!is_first) settings.stream() << ")"; @@ -13594,10 +13598,12 @@ void dump_VkBufferUsageFlagBits2(const VkBufferUsageFlagBits2 object, const ApiD settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT"; is_first = false; } +#if defined(VK_ENABLE_BETA_EXTENSIONS) if (object & VK_BUFFER_USAGE_2_EXECUTION_GRAPH_SCRATCH_BIT_AMDX) { settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_EXECUTION_GRAPH_SCRATCH_BIT_AMDX"; is_first = false; } +#endif if (object & VK_BUFFER_USAGE_2_DESCRIPTOR_HEAP_BIT_EXT) { settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_DESCRIPTOR_HEAP_BIT_EXT"; is_first = false; @@ -13662,10 +13668,12 @@ void dump_VkBufferUsageFlagBits2(const VkBufferUsageFlagBits2 object, const ApiD settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT"; is_first = false; } +#if defined(VK_ENABLE_BETA_EXTENSIONS) if (object & VK_BUFFER_USAGE_2_COMPRESSED_DATA_DGF1_BIT_AMDX) { settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_COMPRESSED_DATA_DGF1_BIT_AMDX"; is_first = false; } +#endif if (object & VK_BUFFER_USAGE_2_DATA_GRAPH_FOREIGN_DESCRIPTOR_BIT_ARM) { settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_DATA_GRAPH_FOREIGN_DESCRIPTOR_BIT_ARM"; is_first = false; @@ -13748,10 +13756,12 @@ void dump_VkPipelineCreateFlagBits2(const VkPipelineCreateFlagBits2 object, cons settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT"; is_first = false; } +#if defined(VK_ENABLE_BETA_EXTENSIONS) if (object & VK_PIPELINE_CREATE_2_EXECUTION_GRAPH_BIT_AMDX) { settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_EXECUTION_GRAPH_BIT_AMDX"; is_first = false; } +#endif if (object & VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT) { settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT"; is_first = false; @@ -15610,10 +15620,12 @@ void dump_VkBuildAccelerationStructureFlagBitsKHR(const VkBuildAccelerationStruc settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_BIT_EXT"; is_first = false; } +#if defined(VK_ENABLE_BETA_EXTENSIONS) if (object & VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_BIT_NV) { settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_BIT_NV"; is_first = false; } +#endif if (object & VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR) { settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR"; is_first = false; diff --git a/layersvt/generated/cputiming_dispatch.h b/layersvt/generated/cputiming_dispatch.h new file mode 100644 index 0000000000..8549b0de71 --- /dev/null +++ b/layersvt/generated/cputiming_dispatch.h @@ -0,0 +1,5986 @@ + +/* Copyright (c) 2015-2026 Valve Corporation + * Copyright (c) 2015-2026 LunarG, Inc. + * Copyright (c) 2015-2017, 2019, 2021 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +/* + * This file is generated from the Khronos Vulkan XML API Registry. + */ + +#include "cputiming_handwritten_functions.h" + +#include "timer.h" + +// Autogen instance functions + +template +VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyInstance"); + auto dispatch_key = get_dispatch_key(instance); + instance_dispatch_table(instance)->DestroyInstance(instance, pAllocator); + destroy_instance_dispatch_table(dispatch_key); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) { + Timer timer("vkEnumeratePhysicalDevices"); + VkResult result = instance_dispatch_table(instance)->EnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices); + + if (pPhysicalDeviceCount != nullptr && pPhysicalDevices != nullptr) { + for (uint32_t i = 0; i < *pPhysicalDeviceCount; i++) { + ApiDumpInstance::current().set_vk_instance(pPhysicalDevices[i], instance); + } + } + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) { + Timer timer("vkGetPhysicalDeviceFeatures"); + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceFeatures(physicalDevice, pFeatures); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) { + Timer timer("vkGetPhysicalDeviceFormatProperties"); + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) { + Timer timer("vkGetPhysicalDeviceImageFormatProperties"); + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) { + Timer timer("vkGetPhysicalDeviceProperties"); + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceProperties(physicalDevice, pProperties); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) { + Timer timer("vkGetPhysicalDeviceQueueFamilyProperties"); + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) { + Timer timer("vkGetPhysicalDeviceMemoryProperties"); + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) { + Timer timer("vkGetPhysicalDeviceSparseImageFormatProperties"); + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) { + Timer timer("vkEnumeratePhysicalDeviceGroups"); + VkResult result = instance_dispatch_table(instance)->EnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) { + Timer timer("vkGetPhysicalDeviceFeatures2"); + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceFeatures2(physicalDevice, pFeatures); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) { + Timer timer("vkGetPhysicalDeviceProperties2"); + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceProperties2(physicalDevice, pProperties); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) { + Timer timer("vkGetPhysicalDeviceFormatProperties2"); + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) { + Timer timer("vkGetPhysicalDeviceImageFormatProperties2"); + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceImageFormatProperties2(physicalDevice, pImageFormatInfo, pImageFormatProperties); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) { + Timer timer("vkGetPhysicalDeviceQueueFamilyProperties2"); + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) { + Timer timer("vkGetPhysicalDeviceMemoryProperties2"); + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) { + Timer timer("vkGetPhysicalDeviceSparseImageFormatProperties2"); + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSparseImageFormatProperties2(physicalDevice, pFormatInfo, pPropertyCount, pProperties); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) { + Timer timer("vkGetPhysicalDeviceExternalBufferProperties"); + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) { + Timer timer("vkGetPhysicalDeviceExternalFenceProperties"); + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) { + Timer timer("vkGetPhysicalDeviceExternalSemaphoreProperties"); + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties) { + Timer timer("vkGetPhysicalDeviceToolProperties"); + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceToolProperties(physicalDevice, pToolCount, pToolProperties); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroySurfaceKHR"); + instance_dispatch_table(instance)->DestroySurfaceKHR(instance, surface, pAllocator); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported) { + Timer timer("vkGetPhysicalDeviceSurfaceSupportKHR"); + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) { + Timer timer("vkGetPhysicalDeviceSurfaceCapabilitiesKHR"); + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) { + Timer timer("vkGetPhysicalDeviceSurfaceFormatsKHR"); + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) { + Timer timer("vkGetPhysicalDeviceSurfacePresentModesKHR"); + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects) { + Timer timer("vkGetPhysicalDevicePresentRectanglesKHR"); + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties) { + Timer timer("vkGetPhysicalDeviceDisplayPropertiesKHR"); + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, pPropertyCount, pProperties); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties) { + Timer timer("vkGetPhysicalDeviceDisplayPlanePropertiesKHR"); + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, pPropertyCount, pProperties); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays) { + Timer timer("vkGetDisplayPlaneSupportedDisplaysKHR"); + VkResult result = instance_dispatch_table(physicalDevice)->GetDisplayPlaneSupportedDisplaysKHR(physicalDevice, planeIndex, pDisplayCount, pDisplays); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties) { + Timer timer("vkGetDisplayModePropertiesKHR"); + VkResult result = instance_dispatch_table(physicalDevice)->GetDisplayModePropertiesKHR(physicalDevice, display, pPropertyCount, pProperties); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode) { + Timer timer("vkCreateDisplayModeKHR"); + VkResult result = instance_dispatch_table(physicalDevice)->CreateDisplayModeKHR(physicalDevice, display, pCreateInfo, pAllocator, pMode); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities) { + Timer timer("vkGetDisplayPlaneCapabilitiesKHR"); + VkResult result = instance_dispatch_table(physicalDevice)->GetDisplayPlaneCapabilitiesKHR(physicalDevice, mode, planeIndex, pCapabilities); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + Timer timer("vkCreateDisplayPlaneSurfaceKHR"); + VkResult result = instance_dispatch_table(instance)->CreateDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); + return result; +} +#if defined(VK_USE_PLATFORM_XLIB_KHR) +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + Timer timer("vkCreateXlibSurfaceKHR"); + VkResult result = instance_dispatch_table(instance)->CreateXlibSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); + return result; +} +template +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID) { + Timer timer("vkGetPhysicalDeviceXlibPresentationSupportKHR"); + VkBool32 result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceXlibPresentationSupportKHR(physicalDevice, queueFamilyIndex, dpy, visualID); + return result; +} +#endif // VK_USE_PLATFORM_XLIB_KHR +#if defined(VK_USE_PLATFORM_XCB_KHR) +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + Timer timer("vkCreateXcbSurfaceKHR"); + VkResult result = instance_dispatch_table(instance)->CreateXcbSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); + return result; +} +template +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id) { + Timer timer("vkGetPhysicalDeviceXcbPresentationSupportKHR"); + VkBool32 result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceXcbPresentationSupportKHR(physicalDevice, queueFamilyIndex, connection, visual_id); + return result; +} +#endif // VK_USE_PLATFORM_XCB_KHR +#if defined(VK_USE_PLATFORM_WAYLAND_KHR) +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + Timer timer("vkCreateWaylandSurfaceKHR"); + VkResult result = instance_dispatch_table(instance)->CreateWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); + return result; +} +template +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display) { + Timer timer("vkGetPhysicalDeviceWaylandPresentationSupportKHR"); + VkBool32 result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceWaylandPresentationSupportKHR(physicalDevice, queueFamilyIndex, display); + return result; +} +#endif // VK_USE_PLATFORM_WAYLAND_KHR +#if defined(VK_USE_PLATFORM_ANDROID_KHR) +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + Timer timer("vkCreateAndroidSurfaceKHR"); + VkResult result = instance_dispatch_table(instance)->CreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); + return result; +} +#endif // VK_USE_PLATFORM_ANDROID_KHR +#if defined(VK_USE_PLATFORM_WIN32_KHR) +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + Timer timer("vkCreateWin32SurfaceKHR"); + VkResult result = instance_dispatch_table(instance)->CreateWin32SurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); + return result; +} +template +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex) { + Timer timer("vkGetPhysicalDeviceWin32PresentationSupportKHR"); + VkBool32 result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice, queueFamilyIndex); + return result; +} +#endif // VK_USE_PLATFORM_WIN32_KHR +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoCapabilitiesKHR(VkPhysicalDevice physicalDevice, const VkVideoProfileInfoKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities) { + Timer timer("vkGetPhysicalDeviceVideoCapabilitiesKHR"); + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceVideoCapabilitiesKHR(physicalDevice, pVideoProfile, pCapabilities); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoFormatPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties) { + Timer timer("vkGetPhysicalDeviceVideoFormatPropertiesKHR"); + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceVideoFormatPropertiesKHR(physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) { + Timer timer("vkGetPhysicalDeviceFeatures2KHR"); + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) { + Timer timer("vkGetPhysicalDeviceProperties2KHR"); + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceProperties2KHR(physicalDevice, pProperties); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) { + Timer timer("vkGetPhysicalDeviceFormatProperties2KHR"); + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceFormatProperties2KHR(physicalDevice, format, pFormatProperties); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) { + Timer timer("vkGetPhysicalDeviceImageFormatProperties2KHR"); + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceImageFormatProperties2KHR(physicalDevice, pImageFormatInfo, pImageFormatProperties); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) { + Timer timer("vkGetPhysicalDeviceQueueFamilyProperties2KHR"); + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) { + Timer timer("vkGetPhysicalDeviceMemoryProperties2KHR"); + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceMemoryProperties2KHR(physicalDevice, pMemoryProperties); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) { + Timer timer("vkGetPhysicalDeviceSparseImageFormatProperties2KHR"); + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice, pFormatInfo, pPropertyCount, pProperties); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroupsKHR(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) { + Timer timer("vkEnumeratePhysicalDeviceGroupsKHR"); + VkResult result = instance_dispatch_table(instance)->EnumeratePhysicalDeviceGroupsKHR(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) { + Timer timer("vkGetPhysicalDeviceExternalBufferPropertiesKHR"); + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceExternalBufferPropertiesKHR(physicalDevice, pExternalBufferInfo, pExternalBufferProperties); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) { + Timer timer("vkGetPhysicalDeviceExternalSemaphorePropertiesKHR"); + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceExternalSemaphorePropertiesKHR(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) { + Timer timer("vkGetPhysicalDeviceExternalFencePropertiesKHR"); + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceExternalFencePropertiesKHR(physicalDevice, pExternalFenceInfo, pExternalFenceProperties); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions) { + Timer timer("vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR"); + VkResult result = instance_dispatch_table(physicalDevice)->EnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses) { + Timer timer("vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR"); + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(physicalDevice, pPerformanceQueryCreateInfo, pNumPasses); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities) { + Timer timer("vkGetPhysicalDeviceSurfaceCapabilities2KHR"); + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice, pSurfaceInfo, pSurfaceCapabilities); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats) { + Timer timer("vkGetPhysicalDeviceSurfaceFormats2KHR"); + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfaceFormats2KHR(physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties) { + Timer timer("vkGetPhysicalDeviceDisplayProperties2KHR"); + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceDisplayProperties2KHR(physicalDevice, pPropertyCount, pProperties); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties) { + Timer timer("vkGetPhysicalDeviceDisplayPlaneProperties2KHR"); + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceDisplayPlaneProperties2KHR(physicalDevice, pPropertyCount, pProperties); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties) { + Timer timer("vkGetDisplayModeProperties2KHR"); + VkResult result = instance_dispatch_table(physicalDevice)->GetDisplayModeProperties2KHR(physicalDevice, display, pPropertyCount, pProperties); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities) { + Timer timer("vkGetDisplayPlaneCapabilities2KHR"); + VkResult result = instance_dispatch_table(physicalDevice)->GetDisplayPlaneCapabilities2KHR(physicalDevice, pDisplayPlaneInfo, pCapabilities); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates) { + Timer timer("vkGetPhysicalDeviceFragmentShadingRatesKHR"); + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceFragmentShadingRatesKHR(physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties) { + Timer timer("vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR"); + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(physicalDevice, pQualityLevelInfo, pQualityLevelProperties); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesKHR* pProperties) { + Timer timer("vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR"); + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceCooperativeMatrixPropertiesKHR(physicalDevice, pPropertyCount, pProperties); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainKHR* pTimeDomains) { + Timer timer("vkGetPhysicalDeviceCalibrateableTimeDomainsKHR"); + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceCalibrateableTimeDomainsKHR(physicalDevice, pTimeDomainCount, pTimeDomains); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback) { + Timer timer("vkCreateDebugReportCallbackEXT"); + VkResult result = instance_dispatch_table(instance)->CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyDebugReportCallbackEXT"); + instance_dispatch_table(instance)->DestroyDebugReportCallbackEXT(instance, callback, pAllocator); +} +template +VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage) { + Timer timer("vkDebugReportMessageEXT"); + instance_dispatch_table(instance)->DebugReportMessageEXT(instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage); +} +#if defined(VK_USE_PLATFORM_GGP) +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateStreamDescriptorSurfaceGGP(VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + Timer timer("vkCreateStreamDescriptorSurfaceGGP"); + VkResult result = instance_dispatch_table(instance)->CreateStreamDescriptorSurfaceGGP(instance, pCreateInfo, pAllocator, pSurface); + return result; +} +#endif // VK_USE_PLATFORM_GGP +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceExternalImageFormatPropertiesNV(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties) { + Timer timer("vkGetPhysicalDeviceExternalImageFormatPropertiesNV"); + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceExternalImageFormatPropertiesNV(physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties); + return result; +} +#if defined(VK_USE_PLATFORM_VI_NN) +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateViSurfaceNN(VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + Timer timer("vkCreateViSurfaceNN"); + VkResult result = instance_dispatch_table(instance)->CreateViSurfaceNN(instance, pCreateInfo, pAllocator, pSurface); + return result; +} +#endif // VK_USE_PLATFORM_VI_NN +template +VKAPI_ATTR VkResult VKAPI_CALL vkReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display) { + Timer timer("vkReleaseDisplayEXT"); + VkResult result = instance_dispatch_table(physicalDevice)->ReleaseDisplayEXT(physicalDevice, display); + return result; +} +#if defined(VK_USE_PLATFORM_XLIB_XRANDR_EXT) +template +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display) { + Timer timer("vkAcquireXlibDisplayEXT"); + VkResult result = instance_dispatch_table(physicalDevice)->AcquireXlibDisplayEXT(physicalDevice, dpy, display); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay) { + Timer timer("vkGetRandROutputDisplayEXT"); + VkResult result = instance_dispatch_table(physicalDevice)->GetRandROutputDisplayEXT(physicalDevice, dpy, rrOutput, pDisplay); + return result; +} +#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities) { + Timer timer("vkGetPhysicalDeviceSurfaceCapabilities2EXT"); + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice, surface, pSurfaceCapabilities); + return result; +} +#if defined(VK_USE_PLATFORM_IOS_MVK) +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateIOSSurfaceMVK(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + Timer timer("vkCreateIOSSurfaceMVK"); + VkResult result = instance_dispatch_table(instance)->CreateIOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface); + return result; +} +#endif // VK_USE_PLATFORM_IOS_MVK +#if defined(VK_USE_PLATFORM_MACOS_MVK) +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + Timer timer("vkCreateMacOSSurfaceMVK"); + VkResult result = instance_dispatch_table(instance)->CreateMacOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface); + return result; +} +#endif // VK_USE_PLATFORM_MACOS_MVK +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger) { + Timer timer("vkCreateDebugUtilsMessengerEXT"); + VkResult result = instance_dispatch_table(instance)->CreateDebugUtilsMessengerEXT(instance, pCreateInfo, pAllocator, pMessenger); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyDebugUtilsMessengerEXT"); + instance_dispatch_table(instance)->DestroyDebugUtilsMessengerEXT(instance, messenger, pAllocator); +} +template +VKAPI_ATTR void VKAPI_CALL vkSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) { + Timer timer("vkSubmitDebugUtilsMessageEXT"); + instance_dispatch_table(instance)->SubmitDebugUtilsMessageEXT(instance, messageSeverity, messageTypes, pCallbackData); +} +template +VKAPI_ATTR VkDeviceSize VKAPI_CALL vkGetPhysicalDeviceDescriptorSizeEXT(VkPhysicalDevice physicalDevice, VkDescriptorType descriptorType) { + Timer timer("vkGetPhysicalDeviceDescriptorSizeEXT"); + VkDeviceSize result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceDescriptorSizeEXT(physicalDevice, descriptorType); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties) { + Timer timer("vkGetPhysicalDeviceMultisamplePropertiesEXT"); + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceMultisamplePropertiesEXT(physicalDevice, samples, pMultisampleProperties); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainKHR* pTimeDomains) { + Timer timer("vkGetPhysicalDeviceCalibrateableTimeDomainsEXT"); + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceCalibrateableTimeDomainsEXT(physicalDevice, pTimeDomainCount, pTimeDomains); + return result; +} +#if defined(VK_USE_PLATFORM_FUCHSIA) +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateImagePipeSurfaceFUCHSIA(VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + Timer timer("vkCreateImagePipeSurfaceFUCHSIA"); + VkResult result = instance_dispatch_table(instance)->CreateImagePipeSurfaceFUCHSIA(instance, pCreateInfo, pAllocator, pSurface); + return result; +} +#endif // VK_USE_PLATFORM_FUCHSIA +#if defined(VK_USE_PLATFORM_METAL_EXT) +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateMetalSurfaceEXT(VkInstance instance, const VkMetalSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + Timer timer("vkCreateMetalSurfaceEXT"); + VkResult result = instance_dispatch_table(instance)->CreateMetalSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface); + return result; +} +#endif // VK_USE_PLATFORM_METAL_EXT +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceToolPropertiesEXT(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties) { + Timer timer("vkGetPhysicalDeviceToolPropertiesEXT"); + + static const VkPhysicalDeviceToolPropertiesEXT api_dump_layer_tool_props = { + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT, + nullptr, + "API Dump Layer", + "2", + VK_TOOL_PURPOSE_PROFILING_BIT_EXT | VK_TOOL_PURPOSE_TRACING_BIT_EXT, + "The VK_LAYER_LUNARG_api_dump utility layer prints API calls, parameters, and values to the identified output stream.", + "VK_LAYER_LUNARG_api_dump"}; + + auto original_pToolProperties = pToolProperties; + if (pToolProperties != nullptr) { + *pToolProperties = api_dump_layer_tool_props; + pToolProperties = ((*pToolCount > 1) ? &pToolProperties[1] : nullptr); + (*pToolCount)--; + } + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceToolPropertiesEXT(physicalDevice, pToolCount, pToolProperties); + if (original_pToolProperties != nullptr) { + pToolProperties = original_pToolProperties; + } + + (*pToolCount)++; + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties) { + Timer timer("vkGetPhysicalDeviceCooperativeMatrixPropertiesNV"); + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceCooperativeMatrixPropertiesNV(physicalDevice, pPropertyCount, pProperties); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations) { + Timer timer("vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV"); + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(physicalDevice, pCombinationCount, pCombinations); + return result; +} +#if defined(VK_USE_PLATFORM_WIN32_KHR) +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModes2EXT(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) { + Timer timer("vkGetPhysicalDeviceSurfacePresentModes2EXT"); + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfacePresentModes2EXT(physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes); + return result; +} +#endif // VK_USE_PLATFORM_WIN32_KHR +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateHeadlessSurfaceEXT(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + Timer timer("vkCreateHeadlessSurfaceEXT"); + VkResult result = instance_dispatch_table(instance)->CreateHeadlessSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display) { + Timer timer("vkAcquireDrmDisplayEXT"); + VkResult result = instance_dispatch_table(physicalDevice)->AcquireDrmDisplayEXT(physicalDevice, drmFd, display); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR* display) { + Timer timer("vkGetDrmDisplayEXT"); + VkResult result = instance_dispatch_table(physicalDevice)->GetDrmDisplayEXT(physicalDevice, drmFd, connectorId, display); + return result; +} +#if defined(VK_USE_PLATFORM_WIN32_KHR) +template +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireWinrtDisplayNV(VkPhysicalDevice physicalDevice, VkDisplayKHR display) { + Timer timer("vkAcquireWinrtDisplayNV"); + VkResult result = instance_dispatch_table(physicalDevice)->AcquireWinrtDisplayNV(physicalDevice, display); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetWinrtDisplayNV(VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR* pDisplay) { + Timer timer("vkGetWinrtDisplayNV"); + VkResult result = instance_dispatch_table(physicalDevice)->GetWinrtDisplayNV(physicalDevice, deviceRelativeId, pDisplay); + return result; +} +#endif // VK_USE_PLATFORM_WIN32_KHR +#if defined(VK_USE_PLATFORM_DIRECTFB_EXT) +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDirectFBSurfaceEXT(VkInstance instance, const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + Timer timer("vkCreateDirectFBSurfaceEXT"); + VkResult result = instance_dispatch_table(instance)->CreateDirectFBSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface); + return result; +} +template +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceDirectFBPresentationSupportEXT(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, IDirectFB* dfb) { + Timer timer("vkGetPhysicalDeviceDirectFBPresentationSupportEXT"); + VkBool32 result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceDirectFBPresentationSupportEXT(physicalDevice, queueFamilyIndex, dfb); + return result; +} +#endif // VK_USE_PLATFORM_DIRECTFB_EXT +#if defined(VK_USE_PLATFORM_SCREEN_QNX) +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateScreenSurfaceQNX(VkInstance instance, const VkScreenSurfaceCreateInfoQNX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + Timer timer("vkCreateScreenSurfaceQNX"); + VkResult result = instance_dispatch_table(instance)->CreateScreenSurfaceQNX(instance, pCreateInfo, pAllocator, pSurface); + return result; +} +template +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceScreenPresentationSupportQNX(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct _screen_window* window) { + Timer timer("vkGetPhysicalDeviceScreenPresentationSupportQNX"); + VkBool32 result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceScreenPresentationSupportQNX(physicalDevice, queueFamilyIndex, window); + return result; +} +#endif // VK_USE_PLATFORM_SCREEN_QNX +template +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalTensorPropertiesARM(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalTensorInfoARM* pExternalTensorInfo, VkExternalTensorPropertiesARM* pExternalTensorProperties) { + Timer timer("vkGetPhysicalDeviceExternalTensorPropertiesARM"); + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceExternalTensorPropertiesARM(physicalDevice, pExternalTensorInfo, pExternalTensorProperties); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceOpticalFlowImageFormatsNV(VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, uint32_t* pFormatCount, VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties) { + Timer timer("vkGetPhysicalDeviceOpticalFlowImageFormatsNV"); + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceOpticalFlowImageFormatsNV(physicalDevice, pOpticalFlowImageFormatInfo, pFormatCount, pImageFormatProperties); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeVectorPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeVectorPropertiesNV* pProperties) { + Timer timer("vkGetPhysicalDeviceCooperativeVectorPropertiesNV"); + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceCooperativeVectorPropertiesNV(physicalDevice, pPropertyCount, pProperties); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pQueueFamilyDataGraphPropertyCount, VkQueueFamilyDataGraphPropertiesARM* pQueueFamilyDataGraphProperties) { + Timer timer("vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM"); + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceQueueFamilyDataGraphPropertiesARM(physicalDevice, queueFamilyIndex, pQueueFamilyDataGraphPropertyCount, pQueueFamilyDataGraphProperties); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM* pQueueFamilyDataGraphProcessingEngineInfo, VkQueueFamilyDataGraphProcessingEnginePropertiesARM* pQueueFamilyDataGraphProcessingEngineProperties) { + Timer timer("vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM"); + instance_dispatch_table(physicalDevice)->GetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM(physicalDevice, pQueueFamilyDataGraphProcessingEngineInfo, pQueueFamilyDataGraphProcessingEngineProperties); +} +#if defined(VK_USE_PLATFORM_OHOS) +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSurfaceOHOS(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + Timer timer("vkCreateSurfaceOHOS"); + VkResult result = instance_dispatch_table(instance)->CreateSurfaceOHOS(instance, pCreateInfo, pAllocator, pSurface); + return result; +} +#endif // VK_USE_PLATFORM_OHOS +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixFlexibleDimensionsPropertiesNV* pProperties) { + Timer timer("vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV"); + VkResult result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(physicalDevice, pPropertyCount, pProperties); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterARM* pCounters, VkPerformanceCounterDescriptionARM* pCounterDescriptions) { + Timer timer("vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM"); + VkResult result = instance_dispatch_table(physicalDevice)->EnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM(physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions); + return result; +} + +// Autogen device functions + +template +VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyDevice"); + device_dispatch_table(device)->DestroyDevice(device, pAllocator); + destroy_device_dispatch_table(get_dispatch_key(device)); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) { + Timer timer("vkGetDeviceQueue"); + device_dispatch_table(device)->GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) { + Timer timer("vkQueueSubmit"); + VkResult result = device_dispatch_table(queue)->QueueSubmit(queue, submitCount, pSubmits, fence); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle(VkQueue queue) { + Timer timer("vkQueueWaitIdle"); + VkResult result = device_dispatch_table(queue)->QueueWaitIdle(queue); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(VkDevice device) { + Timer timer("vkDeviceWaitIdle"); + VkResult result = device_dispatch_table(device)->DeviceWaitIdle(device); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) { + Timer timer("vkAllocateMemory"); + VkResult result = device_dispatch_table(device)->AllocateMemory(device, pAllocateInfo, pAllocator, pMemory); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkFreeMemory"); + device_dispatch_table(device)->FreeMemory(device, memory, pAllocator); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) { + Timer timer("vkMapMemory"); + VkResult result = device_dispatch_table(device)->MapMemory(device, memory, offset, size, flags, ppData); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkUnmapMemory(VkDevice device, VkDeviceMemory memory) { + Timer timer("vkUnmapMemory"); + device_dispatch_table(device)->UnmapMemory(device, memory); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) { + Timer timer("vkFlushMappedMemoryRanges"); + VkResult result = device_dispatch_table(device)->FlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) { + Timer timer("vkInvalidateMappedMemoryRanges"); + VkResult result = device_dispatch_table(device)->InvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) { + Timer timer("vkGetDeviceMemoryCommitment"); + device_dispatch_table(device)->GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) { + Timer timer("vkBindBufferMemory"); + VkResult result = device_dispatch_table(device)->BindBufferMemory(device, buffer, memory, memoryOffset); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) { + Timer timer("vkBindImageMemory"); + VkResult result = device_dispatch_table(device)->BindImageMemory(device, image, memory, memoryOffset); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) { + Timer timer("vkGetBufferMemoryRequirements"); + device_dispatch_table(device)->GetBufferMemoryRequirements(device, buffer, pMemoryRequirements); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) { + Timer timer("vkGetImageMemoryRequirements"); + device_dispatch_table(device)->GetImageMemoryRequirements(device, image, pMemoryRequirements); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) { + Timer timer("vkGetImageSparseMemoryRequirements"); + device_dispatch_table(device)->GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) { + Timer timer("vkQueueBindSparse"); + VkResult result = device_dispatch_table(queue)->QueueBindSparse(queue, bindInfoCount, pBindInfo, fence); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) { + Timer timer("vkCreateFence"); + VkResult result = device_dispatch_table(device)->CreateFence(device, pCreateInfo, pAllocator, pFence); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyFence"); + device_dispatch_table(device)->DestroyFence(device, fence, pAllocator); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) { + Timer timer("vkResetFences"); + VkResult result = device_dispatch_table(device)->ResetFences(device, fenceCount, pFences); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus(VkDevice device, VkFence fence) { + Timer timer("vkGetFenceStatus"); + VkResult result = device_dispatch_table(device)->GetFenceStatus(device, fence); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) { + Timer timer("vkWaitForFences"); + VkResult result = device_dispatch_table(device)->WaitForFences(device, fenceCount, pFences, waitAll, timeout); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) { + Timer timer("vkCreateSemaphore"); + VkResult result = device_dispatch_table(device)->CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroySemaphore"); + device_dispatch_table(device)->DestroySemaphore(device, semaphore, pAllocator); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) { + Timer timer("vkCreateQueryPool"); + VkResult result = device_dispatch_table(device)->CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyQueryPool"); + device_dispatch_table(device)->DestroyQueryPool(device, queryPool, pAllocator); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) { + Timer timer("vkGetQueryPoolResults"); + VkResult result = device_dispatch_table(device)->GetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) { + Timer timer("vkCreateBuffer"); + VkResult result = device_dispatch_table(device)->CreateBuffer(device, pCreateInfo, pAllocator, pBuffer); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyBuffer"); + device_dispatch_table(device)->DestroyBuffer(device, buffer, pAllocator); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) { + Timer timer("vkCreateImage"); + VkResult result = device_dispatch_table(device)->CreateImage(device, pCreateInfo, pAllocator, pImage); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyImage"); + device_dispatch_table(device)->DestroyImage(device, image, pAllocator); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) { + Timer timer("vkGetImageSubresourceLayout"); + device_dispatch_table(device)->GetImageSubresourceLayout(device, image, pSubresource, pLayout); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) { + Timer timer("vkCreateImageView"); + VkResult result = device_dispatch_table(device)->CreateImageView(device, pCreateInfo, pAllocator, pView); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyImageView"); + device_dispatch_table(device)->DestroyImageView(device, imageView, pAllocator); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) { + Timer timer("vkCreateCommandPool"); + VkResult result = device_dispatch_table(device)->CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyCommandPool"); + device_dispatch_table(device)->DestroyCommandPool(device, commandPool, pAllocator); + ApiDumpInstance::current().eraseCmdBufferPool(device, commandPool); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) { + Timer timer("vkResetCommandPool"); + VkResult result = device_dispatch_table(device)->ResetCommandPool(device, commandPool, flags); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) { + Timer timer("vkAllocateCommandBuffers"); + VkResult result = device_dispatch_table(device)->AllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers); + if (result == VK_SUCCESS) + ApiDumpInstance::current().addCmdBuffers( + device, + pAllocateInfo->commandPool, + std::vector(pCommandBuffers, pCommandBuffers + pAllocateInfo->commandBufferCount), + pAllocateInfo->level); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) { + Timer timer("vkFreeCommandBuffers"); + device_dispatch_table(device)->FreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers); + ApiDumpInstance::current().eraseCmdBuffers(device, commandPool, std::vector(pCommandBuffers, pCommandBuffers + commandBufferCount)); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) { + Timer timer("vkBeginCommandBuffer"); + VkResult result = device_dispatch_table(commandBuffer)->BeginCommandBuffer(commandBuffer, pBeginInfo); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer(VkCommandBuffer commandBuffer) { + Timer timer("vkEndCommandBuffer"); + VkResult result = device_dispatch_table(commandBuffer)->EndCommandBuffer(commandBuffer); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) { + Timer timer("vkResetCommandBuffer"); + VkResult result = device_dispatch_table(commandBuffer)->ResetCommandBuffer(commandBuffer, flags); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) { + Timer timer("vkCmdCopyBuffer"); + device_dispatch_table(commandBuffer)->CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) { + Timer timer("vkCmdCopyImage"); + device_dispatch_table(commandBuffer)->CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) { + Timer timer("vkCmdCopyBufferToImage"); + device_dispatch_table(commandBuffer)->CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) { + Timer timer("vkCmdCopyImageToBuffer"); + device_dispatch_table(commandBuffer)->CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData) { + Timer timer("vkCmdUpdateBuffer"); + device_dispatch_table(commandBuffer)->CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) { + Timer timer("vkCmdFillBuffer"); + device_dispatch_table(commandBuffer)->CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data); +} +template +VKAPI_ATTR void VKAPI_CALL 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) { + Timer timer("vkCmdPipelineBarrier"); + device_dispatch_table(commandBuffer)->CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) { + Timer timer("vkCmdBeginQuery"); + device_dispatch_table(commandBuffer)->CmdBeginQuery(commandBuffer, queryPool, query, flags); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) { + Timer timer("vkCmdEndQuery"); + device_dispatch_table(commandBuffer)->CmdEndQuery(commandBuffer, queryPool, query); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) { + Timer timer("vkCmdResetQueryPool"); + device_dispatch_table(commandBuffer)->CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) { + Timer timer("vkCmdWriteTimestamp"); + device_dispatch_table(commandBuffer)->CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) { + Timer timer("vkCmdCopyQueryPoolResults"); + device_dispatch_table(commandBuffer)->CmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) { + Timer timer("vkCmdExecuteCommands"); + device_dispatch_table(commandBuffer)->CmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) { + Timer timer("vkCreateEvent"); + VkResult result = device_dispatch_table(device)->CreateEvent(device, pCreateInfo, pAllocator, pEvent); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyEvent"); + device_dispatch_table(device)->DestroyEvent(device, event, pAllocator); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus(VkDevice device, VkEvent event) { + Timer timer("vkGetEventStatus"); + VkResult result = device_dispatch_table(device)->GetEventStatus(device, event); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent(VkDevice device, VkEvent event) { + Timer timer("vkSetEvent"); + VkResult result = device_dispatch_table(device)->SetEvent(device, event); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent(VkDevice device, VkEvent event) { + Timer timer("vkResetEvent"); + VkResult result = device_dispatch_table(device)->ResetEvent(device, event); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) { + Timer timer("vkCreateBufferView"); + VkResult result = device_dispatch_table(device)->CreateBufferView(device, pCreateInfo, pAllocator, pView); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyBufferView"); + device_dispatch_table(device)->DestroyBufferView(device, bufferView, pAllocator); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) { + Timer timer("vkCreateShaderModule"); + VkResult result = device_dispatch_table(device)->CreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyShaderModule"); + device_dispatch_table(device)->DestroyShaderModule(device, shaderModule, pAllocator); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) { + Timer timer("vkCreatePipelineCache"); + VkResult result = device_dispatch_table(device)->CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyPipelineCache"); + device_dispatch_table(device)->DestroyPipelineCache(device, pipelineCache, pAllocator); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) { + Timer timer("vkGetPipelineCacheData"); + VkResult result = device_dispatch_table(device)->GetPipelineCacheData(device, pipelineCache, pDataSize, pData); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) { + Timer timer("vkMergePipelineCaches"); + VkResult result = device_dispatch_table(device)->MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { + Timer timer("vkCreateComputePipelines"); + VkResult result = device_dispatch_table(device)->CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyPipeline"); + device_dispatch_table(device)->DestroyPipeline(device, pipeline, pAllocator); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) { + Timer timer("vkCreatePipelineLayout"); + VkResult result = device_dispatch_table(device)->CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyPipelineLayout"); + device_dispatch_table(device)->DestroyPipelineLayout(device, pipelineLayout, pAllocator); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) { + Timer timer("vkCreateSampler"); + VkResult result = device_dispatch_table(device)->CreateSampler(device, pCreateInfo, pAllocator, pSampler); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroySampler"); + device_dispatch_table(device)->DestroySampler(device, sampler, pAllocator); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) { + Timer timer("vkCreateDescriptorSetLayout"); + VkResult result = device_dispatch_table(device)->CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyDescriptorSetLayout"); + device_dispatch_table(device)->DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) { + Timer timer("vkCreateDescriptorPool"); + VkResult result = device_dispatch_table(device)->CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyDescriptorPool"); + device_dispatch_table(device)->DestroyDescriptorPool(device, descriptorPool, pAllocator); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) { + Timer timer("vkResetDescriptorPool"); + VkResult result = device_dispatch_table(device)->ResetDescriptorPool(device, descriptorPool, flags); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) { + Timer timer("vkAllocateDescriptorSets"); + VkResult result = device_dispatch_table(device)->AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) { + Timer timer("vkFreeDescriptorSets"); + VkResult result = device_dispatch_table(device)->FreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) { + Timer timer("vkUpdateDescriptorSets"); + device_dispatch_table(device)->UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) { + Timer timer("vkCmdBindPipeline"); + device_dispatch_table(commandBuffer)->CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) { + Timer timer("vkCmdBindDescriptorSets"); + device_dispatch_table(commandBuffer)->CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { + Timer timer("vkCmdClearColorImage"); + device_dispatch_table(commandBuffer)->CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) { + Timer timer("vkCmdDispatch"); + device_dispatch_table(commandBuffer)->CmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) { + Timer timer("vkCmdDispatchIndirect"); + device_dispatch_table(commandBuffer)->CmdDispatchIndirect(commandBuffer, buffer, offset); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) { + Timer timer("vkCmdSetEvent"); + device_dispatch_table(commandBuffer)->CmdSetEvent(commandBuffer, event, stageMask); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) { + Timer timer("vkCmdResetEvent"); + device_dispatch_table(commandBuffer)->CmdResetEvent(commandBuffer, event, stageMask); +} +template +VKAPI_ATTR void VKAPI_CALL 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) { + Timer timer("vkCmdWaitEvents"); + device_dispatch_table(commandBuffer)->CmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) { + Timer timer("vkCmdPushConstants"); + device_dispatch_table(commandBuffer)->CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { + Timer timer("vkCreateGraphicsPipelines"); + VkResult result = device_dispatch_table(device)->CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) { + Timer timer("vkCreateFramebuffer"); + VkResult result = device_dispatch_table(device)->CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyFramebuffer"); + device_dispatch_table(device)->DestroyFramebuffer(device, framebuffer, pAllocator); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) { + Timer timer("vkCreateRenderPass"); + VkResult result = device_dispatch_table(device)->CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyRenderPass"); + device_dispatch_table(device)->DestroyRenderPass(device, renderPass, pAllocator); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) { + Timer timer("vkGetRenderAreaGranularity"); + device_dispatch_table(device)->GetRenderAreaGranularity(device, renderPass, pGranularity); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) { + Timer timer("vkCmdSetViewport"); + device_dispatch_table(commandBuffer)->CmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) { + Timer timer("vkCmdSetScissor"); + device_dispatch_table(commandBuffer)->CmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) { + Timer timer("vkCmdSetLineWidth"); + device_dispatch_table(commandBuffer)->CmdSetLineWidth(commandBuffer, lineWidth); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) { + Timer timer("vkCmdSetDepthBias"); + device_dispatch_table(commandBuffer)->CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) { + Timer timer("vkCmdSetBlendConstants"); + device_dispatch_table(commandBuffer)->CmdSetBlendConstants(commandBuffer, blendConstants); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) { + Timer timer("vkCmdSetDepthBounds"); + device_dispatch_table(commandBuffer)->CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) { + Timer timer("vkCmdSetStencilCompareMask"); + device_dispatch_table(commandBuffer)->CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) { + Timer timer("vkCmdSetStencilWriteMask"); + device_dispatch_table(commandBuffer)->CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) { + Timer timer("vkCmdSetStencilReference"); + device_dispatch_table(commandBuffer)->CmdSetStencilReference(commandBuffer, faceMask, reference); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) { + Timer timer("vkCmdBindIndexBuffer"); + device_dispatch_table(commandBuffer)->CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) { + Timer timer("vkCmdBindVertexBuffers"); + device_dispatch_table(commandBuffer)->CmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) { + Timer timer("vkCmdDraw"); + device_dispatch_table(commandBuffer)->CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) { + Timer timer("vkCmdDrawIndexed"); + device_dispatch_table(commandBuffer)->CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) { + Timer timer("vkCmdDrawIndirect"); + device_dispatch_table(commandBuffer)->CmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) { + Timer timer("vkCmdDrawIndexedIndirect"); + device_dispatch_table(commandBuffer)->CmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) { + Timer timer("vkCmdBlitImage"); + device_dispatch_table(commandBuffer)->CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { + Timer timer("vkCmdClearDepthStencilImage"); + device_dispatch_table(commandBuffer)->CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) { + Timer timer("vkCmdClearAttachments"); + device_dispatch_table(commandBuffer)->CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) { + Timer timer("vkCmdResolveImage"); + device_dispatch_table(commandBuffer)->CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) { + Timer timer("vkCmdBeginRenderPass"); + device_dispatch_table(commandBuffer)->CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) { + Timer timer("vkCmdNextSubpass"); + device_dispatch_table(commandBuffer)->CmdNextSubpass(commandBuffer, contents); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass(VkCommandBuffer commandBuffer) { + Timer timer("vkCmdEndRenderPass"); + device_dispatch_table(commandBuffer)->CmdEndRenderPass(commandBuffer); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) { + Timer timer("vkBindBufferMemory2"); + VkResult result = device_dispatch_table(device)->BindBufferMemory2(device, bindInfoCount, pBindInfos); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) { + Timer timer("vkBindImageMemory2"); + VkResult result = device_dispatch_table(device)->BindImageMemory2(device, bindInfoCount, pBindInfos); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) { + Timer timer("vkGetDeviceGroupPeerMemoryFeatures"); + device_dispatch_table(device)->GetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask) { + Timer timer("vkCmdSetDeviceMask"); + device_dispatch_table(commandBuffer)->CmdSetDeviceMask(commandBuffer, deviceMask); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + Timer timer("vkGetImageMemoryRequirements2"); + device_dispatch_table(device)->GetImageMemoryRequirements2(device, pInfo, pMemoryRequirements); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + Timer timer("vkGetBufferMemoryRequirements2"); + device_dispatch_table(device)->GetBufferMemoryRequirements2(device, pInfo, pMemoryRequirements); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { + Timer timer("vkGetImageSparseMemoryRequirements2"); + device_dispatch_table(device)->GetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); +} +template +VKAPI_ATTR void VKAPI_CALL vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) { + Timer timer("vkTrimCommandPool"); + device_dispatch_table(device)->TrimCommandPool(device, commandPool, flags); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) { + Timer timer("vkGetDeviceQueue2"); + device_dispatch_table(device)->GetDeviceQueue2(device, pQueueInfo, pQueue); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) { + Timer timer("vkCmdDispatchBase"); + device_dispatch_table(commandBuffer)->CmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) { + Timer timer("vkCreateDescriptorUpdateTemplate"); + VkResult result = device_dispatch_table(device)->CreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyDescriptorUpdateTemplate"); + device_dispatch_table(device)->DestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator); +} +template +VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) { + Timer timer("vkUpdateDescriptorSetWithTemplate"); + device_dispatch_table(device)->UpdateDescriptorSetWithTemplate(device, descriptorSet, descriptorUpdateTemplate, pData); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) { + Timer timer("vkGetDescriptorSetLayoutSupport"); + device_dispatch_table(device)->GetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) { + Timer timer("vkCreateSamplerYcbcrConversion"); + VkResult result = device_dispatch_table(device)->CreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroySamplerYcbcrConversion"); + device_dispatch_table(device)->DestroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator); +} +template +VKAPI_ATTR void VKAPI_CALL vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) { + Timer timer("vkResetQueryPool"); + device_dispatch_table(device)->ResetQueryPool(device, queryPool, firstQuery, queryCount); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t* pValue) { + Timer timer("vkGetSemaphoreCounterValue"); + VkResult result = device_dispatch_table(device)->GetSemaphoreCounterValue(device, semaphore, pValue); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout) { + Timer timer("vkWaitSemaphores"); + VkResult result = device_dispatch_table(device)->WaitSemaphores(device, pWaitInfo, timeout); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) { + Timer timer("vkSignalSemaphore"); + VkResult result = device_dispatch_table(device)->SignalSemaphore(device, pSignalInfo); + return result; +} +template +VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) { + Timer timer("vkGetBufferDeviceAddress"); + VkDeviceAddress result = device_dispatch_table(device)->GetBufferDeviceAddress(device, pInfo); + return result; +} +template +VKAPI_ATTR uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) { + Timer timer("vkGetBufferOpaqueCaptureAddress"); + uint64_t result = device_dispatch_table(device)->GetBufferOpaqueCaptureAddress(device, pInfo); + return result; +} +template +VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) { + Timer timer("vkGetDeviceMemoryOpaqueCaptureAddress"); + uint64_t result = device_dispatch_table(device)->GetDeviceMemoryOpaqueCaptureAddress(device, pInfo); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { + Timer timer("vkCmdDrawIndirectCount"); + device_dispatch_table(commandBuffer)->CmdDrawIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { + Timer timer("vkCmdDrawIndexedIndirectCount"); + device_dispatch_table(commandBuffer)->CmdDrawIndexedIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) { + Timer timer("vkCreateRenderPass2"); + VkResult result = device_dispatch_table(device)->CreateRenderPass2(device, pCreateInfo, pAllocator, pRenderPass); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo) { + Timer timer("vkCmdBeginRenderPass2"); + device_dispatch_table(commandBuffer)->CmdBeginRenderPass2(commandBuffer, pRenderPassBegin, pSubpassBeginInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass2(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo) { + Timer timer("vkCmdNextSubpass2"); + device_dispatch_table(commandBuffer)->CmdNextSubpass2(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo) { + Timer timer("vkCmdEndRenderPass2"); + device_dispatch_table(commandBuffer)->CmdEndRenderPass2(commandBuffer, pSubpassEndInfo); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreatePrivateDataSlot(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) { + Timer timer("vkCreatePrivateDataSlot"); + VkResult result = device_dispatch_table(device)->CreatePrivateDataSlot(device, pCreateInfo, pAllocator, pPrivateDataSlot); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyPrivateDataSlot"); + device_dispatch_table(device)->DestroyPrivateDataSlot(device, privateDataSlot, pAllocator); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkSetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) { + Timer timer("vkSetPrivateData"); + VkResult result = device_dispatch_table(device)->SetPrivateData(device, objectType, objectHandle, privateDataSlot, data); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkGetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData) { + Timer timer("vkGetPrivateData"); + device_dispatch_table(device)->GetPrivateData(device, objectType, objectHandle, privateDataSlot, pData); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) { + Timer timer("vkCmdPipelineBarrier2"); + device_dispatch_table(commandBuffer)->CmdPipelineBarrier2(commandBuffer, pDependencyInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) { + Timer timer("vkCmdWriteTimestamp2"); + device_dispatch_table(commandBuffer)->CmdWriteTimestamp2(commandBuffer, stage, queryPool, query); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence) { + Timer timer("vkQueueSubmit2"); + VkResult result = device_dispatch_table(queue)->QueueSubmit2(queue, submitCount, pSubmits, fence); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer2(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) { + Timer timer("vkCmdCopyBuffer2"); + device_dispatch_table(commandBuffer)->CmdCopyBuffer2(commandBuffer, pCopyBufferInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage2(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) { + Timer timer("vkCmdCopyImage2"); + device_dispatch_table(commandBuffer)->CmdCopyImage2(commandBuffer, pCopyImageInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage2(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) { + Timer timer("vkCmdCopyBufferToImage2"); + device_dispatch_table(commandBuffer)->CmdCopyBufferToImage2(commandBuffer, pCopyBufferToImageInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer2(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) { + Timer timer("vkCmdCopyImageToBuffer2"); + device_dispatch_table(commandBuffer)->CmdCopyImageToBuffer2(commandBuffer, pCopyImageToBufferInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetDeviceBufferMemoryRequirements(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + Timer timer("vkGetDeviceBufferMemoryRequirements"); + device_dispatch_table(device)->GetDeviceBufferMemoryRequirements(device, pInfo, pMemoryRequirements); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + Timer timer("vkGetDeviceImageMemoryRequirements"); + device_dispatch_table(device)->GetDeviceImageMemoryRequirements(device, pInfo, pMemoryRequirements); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSparseMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { + Timer timer("vkGetDeviceImageSparseMemoryRequirements"); + device_dispatch_table(device)->GetDeviceImageSparseMemoryRequirements(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) { + Timer timer("vkCmdSetEvent2"); + device_dispatch_table(commandBuffer)->CmdSetEvent2(commandBuffer, event, pDependencyInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) { + Timer timer("vkCmdResetEvent2"); + device_dispatch_table(commandBuffer)->CmdResetEvent2(commandBuffer, event, stageMask); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) { + Timer timer("vkCmdWaitEvents2"); + device_dispatch_table(commandBuffer)->CmdWaitEvents2(commandBuffer, eventCount, pEvents, pDependencyInfos); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage2(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) { + Timer timer("vkCmdBlitImage2"); + device_dispatch_table(commandBuffer)->CmdBlitImage2(commandBuffer, pBlitImageInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage2(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo) { + Timer timer("vkCmdResolveImage2"); + device_dispatch_table(commandBuffer)->CmdResolveImage2(commandBuffer, pResolveImageInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo) { + Timer timer("vkCmdBeginRendering"); + device_dispatch_table(commandBuffer)->CmdBeginRendering(commandBuffer, pRenderingInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdEndRendering(VkCommandBuffer commandBuffer) { + Timer timer("vkCmdEndRendering"); + device_dispatch_table(commandBuffer)->CmdEndRendering(commandBuffer); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) { + Timer timer("vkCmdSetCullMode"); + device_dispatch_table(commandBuffer)->CmdSetCullMode(commandBuffer, cullMode); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace) { + Timer timer("vkCmdSetFrontFace"); + device_dispatch_table(commandBuffer)->CmdSetFrontFace(commandBuffer, frontFace); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveTopology(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) { + Timer timer("vkCmdSetPrimitiveTopology"); + device_dispatch_table(commandBuffer)->CmdSetPrimitiveTopology(commandBuffer, primitiveTopology); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) { + Timer timer("vkCmdSetViewportWithCount"); + device_dispatch_table(commandBuffer)->CmdSetViewportWithCount(commandBuffer, viewportCount, pViewports); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) { + Timer timer("vkCmdSetScissorWithCount"); + device_dispatch_table(commandBuffer)->CmdSetScissorWithCount(commandBuffer, scissorCount, pScissors); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) { + Timer timer("vkCmdBindVertexBuffers2"); + device_dispatch_table(commandBuffer)->CmdBindVertexBuffers2(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) { + Timer timer("vkCmdSetDepthTestEnable"); + device_dispatch_table(commandBuffer)->CmdSetDepthTestEnable(commandBuffer, depthTestEnable); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) { + Timer timer("vkCmdSetDepthWriteEnable"); + device_dispatch_table(commandBuffer)->CmdSetDepthWriteEnable(commandBuffer, depthWriteEnable); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) { + Timer timer("vkCmdSetDepthCompareOp"); + device_dispatch_table(commandBuffer)->CmdSetDepthCompareOp(commandBuffer, depthCompareOp); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) { + Timer timer("vkCmdSetDepthBoundsTestEnable"); + device_dispatch_table(commandBuffer)->CmdSetDepthBoundsTestEnable(commandBuffer, depthBoundsTestEnable); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilTestEnable(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) { + Timer timer("vkCmdSetStencilTestEnable"); + device_dispatch_table(commandBuffer)->CmdSetStencilTestEnable(commandBuffer, stencilTestEnable); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) { + Timer timer("vkCmdSetStencilOp"); + device_dispatch_table(commandBuffer)->CmdSetStencilOp(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) { + Timer timer("vkCmdSetRasterizerDiscardEnable"); + device_dispatch_table(commandBuffer)->CmdSetRasterizerDiscardEnable(commandBuffer, rasterizerDiscardEnable); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) { + Timer timer("vkCmdSetDepthBiasEnable"); + device_dispatch_table(commandBuffer)->CmdSetDepthBiasEnable(commandBuffer, depthBiasEnable); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) { + Timer timer("vkCmdSetPrimitiveRestartEnable"); + device_dispatch_table(commandBuffer)->CmdSetPrimitiveRestartEnable(commandBuffer, primitiveRestartEnable); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory2(VkDevice device, const VkMemoryMapInfo* pMemoryMapInfo, void** ppData) { + Timer timer("vkMapMemory2"); + VkResult result = device_dispatch_table(device)->MapMemory2(device, pMemoryMapInfo, ppData); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkUnmapMemory2(VkDevice device, const VkMemoryUnmapInfo* pMemoryUnmapInfo) { + Timer timer("vkUnmapMemory2"); + VkResult result = device_dispatch_table(device)->UnmapMemory2(device, pMemoryUnmapInfo); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSubresourceLayout(VkDevice device, const VkDeviceImageSubresourceInfo* pInfo, VkSubresourceLayout2* pLayout) { + Timer timer("vkGetDeviceImageSubresourceLayout"); + device_dispatch_table(device)->GetDeviceImageSubresourceLayout(device, pInfo, pLayout); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout2(VkDevice device, VkImage image, const VkImageSubresource2* pSubresource, VkSubresourceLayout2* pLayout) { + Timer timer("vkGetImageSubresourceLayout2"); + device_dispatch_table(device)->GetImageSubresourceLayout2(device, image, pSubresource, pLayout); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToImage(VkDevice device, const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo) { + Timer timer("vkCopyMemoryToImage"); + VkResult result = device_dispatch_table(device)->CopyMemoryToImage(device, pCopyMemoryToImageInfo); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCopyImageToMemory(VkDevice device, const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo) { + Timer timer("vkCopyImageToMemory"); + VkResult result = device_dispatch_table(device)->CopyImageToMemory(device, pCopyImageToMemoryInfo); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCopyImageToImage(VkDevice device, const VkCopyImageToImageInfo* pCopyImageToImageInfo) { + Timer timer("vkCopyImageToImage"); + VkResult result = device_dispatch_table(device)->CopyImageToImage(device, pCopyImageToImageInfo); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkTransitionImageLayout(VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfo* pTransitions) { + Timer timer("vkTransitionImageLayout"); + VkResult result = device_dispatch_table(device)->TransitionImageLayout(device, transitionCount, pTransitions); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSet(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) { + Timer timer("vkCmdPushDescriptorSet"); + device_dispatch_table(commandBuffer)->CmdPushDescriptorSet(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplate(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData) { + Timer timer("vkCmdPushDescriptorSetWithTemplate"); + device_dispatch_table(commandBuffer)->CmdPushDescriptorSetWithTemplate(commandBuffer, descriptorUpdateTemplate, layout, set, pData); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets2(VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo) { + Timer timer("vkCmdBindDescriptorSets2"); + device_dispatch_table(commandBuffer)->CmdBindDescriptorSets2(commandBuffer, pBindDescriptorSetsInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants2(VkCommandBuffer commandBuffer, const VkPushConstantsInfo* pPushConstantsInfo) { + Timer timer("vkCmdPushConstants2"); + device_dispatch_table(commandBuffer)->CmdPushConstants2(commandBuffer, pPushConstantsInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSet2(VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfo* pPushDescriptorSetInfo) { + Timer timer("vkCmdPushDescriptorSet2"); + device_dispatch_table(commandBuffer)->CmdPushDescriptorSet2(commandBuffer, pPushDescriptorSetInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplate2(VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo) { + Timer timer("vkCmdPushDescriptorSetWithTemplate2"); + device_dispatch_table(commandBuffer)->CmdPushDescriptorSetWithTemplate2(commandBuffer, pPushDescriptorSetWithTemplateInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStipple(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) { + Timer timer("vkCmdSetLineStipple"); + device_dispatch_table(commandBuffer)->CmdSetLineStipple(commandBuffer, lineStippleFactor, lineStipplePattern); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer2(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType) { + Timer timer("vkCmdBindIndexBuffer2"); + device_dispatch_table(commandBuffer)->CmdBindIndexBuffer2(commandBuffer, buffer, offset, size, indexType); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetRenderingAreaGranularity(VkDevice device, const VkRenderingAreaInfo* pRenderingAreaInfo, VkExtent2D* pGranularity) { + Timer timer("vkGetRenderingAreaGranularity"); + device_dispatch_table(device)->GetRenderingAreaGranularity(device, pRenderingAreaInfo, pGranularity); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetRenderingAttachmentLocations(VkCommandBuffer commandBuffer, const VkRenderingAttachmentLocationInfo* pLocationInfo) { + Timer timer("vkCmdSetRenderingAttachmentLocations"); + device_dispatch_table(commandBuffer)->CmdSetRenderingAttachmentLocations(commandBuffer, pLocationInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetRenderingInputAttachmentIndices(VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo) { + Timer timer("vkCmdSetRenderingInputAttachmentIndices"); + device_dispatch_table(commandBuffer)->CmdSetRenderingInputAttachmentIndices(commandBuffer, pInputAttachmentIndexInfo); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) { + Timer timer("vkCreateSwapchainKHR"); + VkResult result = device_dispatch_table(device)->CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroySwapchainKHR"); + device_dispatch_table(device)->DestroySwapchainKHR(device, swapchain, pAllocator); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) { + Timer timer("vkGetSwapchainImagesKHR"); + VkResult result = device_dispatch_table(device)->GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) { + Timer timer("vkAcquireNextImageKHR"); + VkResult result = device_dispatch_table(device)->AcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo) { + Timer timer("vkQueuePresentKHR"); + VkResult result = device_dispatch_table(queue)->QueuePresentKHR(queue, pPresentInfo); + ApiDumpInstance::current().nextFrame(); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) { + Timer timer("vkGetDeviceGroupPresentCapabilitiesKHR"); + VkResult result = device_dispatch_table(device)->GetDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes) { + Timer timer("vkGetDeviceGroupSurfacePresentModesKHR"); + VkResult result = device_dispatch_table(device)->GetDeviceGroupSurfacePresentModesKHR(device, surface, pModes); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex) { + Timer timer("vkAcquireNextImage2KHR"); + VkResult result = device_dispatch_table(device)->AcquireNextImage2KHR(device, pAcquireInfo, pImageIndex); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains) { + Timer timer("vkCreateSharedSwapchainsKHR"); + VkResult result = device_dispatch_table(device)->CreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateVideoSessionKHR(VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession) { + Timer timer("vkCreateVideoSessionKHR"); + VkResult result = device_dispatch_table(device)->CreateVideoSessionKHR(device, pCreateInfo, pAllocator, pVideoSession); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyVideoSessionKHR(VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyVideoSessionKHR"); + device_dispatch_table(device)->DestroyVideoSessionKHR(device, videoSession, pAllocator); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetVideoSessionMemoryRequirementsKHR(VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements) { + Timer timer("vkGetVideoSessionMemoryRequirementsKHR"); + VkResult result = device_dispatch_table(device)->GetVideoSessionMemoryRequirementsKHR(device, videoSession, pMemoryRequirementsCount, pMemoryRequirements); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkBindVideoSessionMemoryKHR(VkDevice device, VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos) { + Timer timer("vkBindVideoSessionMemoryKHR"); + VkResult result = device_dispatch_table(device)->BindVideoSessionMemoryKHR(device, videoSession, bindSessionMemoryInfoCount, pBindSessionMemoryInfos); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateVideoSessionParametersKHR(VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters) { + Timer timer("vkCreateVideoSessionParametersKHR"); + VkResult result = device_dispatch_table(device)->CreateVideoSessionParametersKHR(device, pCreateInfo, pAllocator, pVideoSessionParameters); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkUpdateVideoSessionParametersKHR(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo) { + Timer timer("vkUpdateVideoSessionParametersKHR"); + VkResult result = device_dispatch_table(device)->UpdateVideoSessionParametersKHR(device, videoSessionParameters, pUpdateInfo); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyVideoSessionParametersKHR(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyVideoSessionParametersKHR"); + device_dispatch_table(device)->DestroyVideoSessionParametersKHR(device, videoSessionParameters, pAllocator); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdBeginVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR* pBeginInfo) { + Timer timer("vkCmdBeginVideoCodingKHR"); + device_dispatch_table(commandBuffer)->CmdBeginVideoCodingKHR(commandBuffer, pBeginInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdEndVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR* pEndCodingInfo) { + Timer timer("vkCmdEndVideoCodingKHR"); + device_dispatch_table(commandBuffer)->CmdEndVideoCodingKHR(commandBuffer, pEndCodingInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdControlVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo) { + Timer timer("vkCmdControlVideoCodingKHR"); + device_dispatch_table(commandBuffer)->CmdControlVideoCodingKHR(commandBuffer, pCodingControlInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdDecodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pDecodeInfo) { + Timer timer("vkCmdDecodeVideoKHR"); + device_dispatch_table(commandBuffer)->CmdDecodeVideoKHR(commandBuffer, pDecodeInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderingKHR(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo) { + Timer timer("vkCmdBeginRenderingKHR"); + device_dispatch_table(commandBuffer)->CmdBeginRenderingKHR(commandBuffer, pRenderingInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderingKHR(VkCommandBuffer commandBuffer) { + Timer timer("vkCmdEndRenderingKHR"); + device_dispatch_table(commandBuffer)->CmdEndRenderingKHR(commandBuffer); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) { + Timer timer("vkGetDeviceGroupPeerMemoryFeaturesKHR"); + device_dispatch_table(device)->GetDeviceGroupPeerMemoryFeaturesKHR(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask) { + Timer timer("vkCmdSetDeviceMaskKHR"); + device_dispatch_table(commandBuffer)->CmdSetDeviceMaskKHR(commandBuffer, deviceMask); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) { + Timer timer("vkCmdDispatchBaseKHR"); + device_dispatch_table(commandBuffer)->CmdDispatchBaseKHR(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); +} +template +VKAPI_ATTR void VKAPI_CALL vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) { + Timer timer("vkTrimCommandPoolKHR"); + device_dispatch_table(device)->TrimCommandPoolKHR(device, commandPool, flags); +} +#if defined(VK_USE_PLATFORM_WIN32_KHR) +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR(VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) { + Timer timer("vkGetMemoryWin32HandleKHR"); + VkResult result = device_dispatch_table(device)->GetMemoryWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) { + Timer timer("vkGetMemoryWin32HandlePropertiesKHR"); + VkResult result = device_dispatch_table(device)->GetMemoryWin32HandlePropertiesKHR(device, handleType, handle, pMemoryWin32HandleProperties); + return result; +} +#endif // VK_USE_PLATFORM_WIN32_KHR +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdKHR(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd) { + Timer timer("vkGetMemoryFdKHR"); + VkResult result = device_dispatch_table(device)->GetMemoryFdKHR(device, pGetFdInfo, pFd); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties) { + Timer timer("vkGetMemoryFdPropertiesKHR"); + VkResult result = device_dispatch_table(device)->GetMemoryFdPropertiesKHR(device, handleType, fd, pMemoryFdProperties); + return result; +} +#if defined(VK_USE_PLATFORM_WIN32_KHR) +template +VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHR(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo) { + Timer timer("vkImportSemaphoreWin32HandleKHR"); + VkResult result = device_dispatch_table(device)->ImportSemaphoreWin32HandleKHR(device, pImportSemaphoreWin32HandleInfo); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHR(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) { + Timer timer("vkGetSemaphoreWin32HandleKHR"); + VkResult result = device_dispatch_table(device)->GetSemaphoreWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); + return result; +} +#endif // VK_USE_PLATFORM_WIN32_KHR +template +VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreFdKHR(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) { + Timer timer("vkImportSemaphoreFdKHR"); + VkResult result = device_dispatch_table(device)->ImportSemaphoreFdKHR(device, pImportSemaphoreFdInfo); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd) { + Timer timer("vkGetSemaphoreFdKHR"); + VkResult result = device_dispatch_table(device)->GetSemaphoreFdKHR(device, pGetFdInfo, pFd); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) { + Timer timer("vkCmdPushDescriptorSetKHR"); + device_dispatch_table(commandBuffer)->CmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData) { + Timer timer("vkCmdPushDescriptorSetWithTemplateKHR"); + device_dispatch_table(commandBuffer)->CmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplateKHR(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) { + Timer timer("vkCreateDescriptorUpdateTemplateKHR"); + VkResult result = device_dispatch_table(device)->CreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplateKHR(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyDescriptorUpdateTemplateKHR"); + device_dispatch_table(device)->DestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator); +} +template +VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) { + Timer timer("vkUpdateDescriptorSetWithTemplateKHR"); + device_dispatch_table(device)->UpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate, pData); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) { + Timer timer("vkCreateRenderPass2KHR"); + VkResult result = device_dispatch_table(device)->CreateRenderPass2KHR(device, pCreateInfo, pAllocator, pRenderPass); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo) { + Timer timer("vkCmdBeginRenderPass2KHR"); + device_dispatch_table(commandBuffer)->CmdBeginRenderPass2KHR(commandBuffer, pRenderPassBegin, pSubpassBeginInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo) { + Timer timer("vkCmdNextSubpass2KHR"); + device_dispatch_table(commandBuffer)->CmdNextSubpass2KHR(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo) { + Timer timer("vkCmdEndRenderPass2KHR"); + device_dispatch_table(commandBuffer)->CmdEndRenderPass2KHR(commandBuffer, pSubpassEndInfo); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain) { + Timer timer("vkGetSwapchainStatusKHR"); + VkResult result = device_dispatch_table(device)->GetSwapchainStatusKHR(device, swapchain); + return result; +} +#if defined(VK_USE_PLATFORM_WIN32_KHR) +template +VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceWin32HandleKHR(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo) { + Timer timer("vkImportFenceWin32HandleKHR"); + VkResult result = device_dispatch_table(device)->ImportFenceWin32HandleKHR(device, pImportFenceWin32HandleInfo); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) { + Timer timer("vkGetFenceWin32HandleKHR"); + VkResult result = device_dispatch_table(device)->GetFenceWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); + return result; +} +#endif // VK_USE_PLATFORM_WIN32_KHR +template +VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceFdKHR(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo) { + Timer timer("vkImportFenceFdKHR"); + VkResult result = device_dispatch_table(device)->ImportFenceFdKHR(device, pImportFenceFdInfo); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd) { + Timer timer("vkGetFenceFdKHR"); + VkResult result = device_dispatch_table(device)->GetFenceFdKHR(device, pGetFdInfo, pFd); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireProfilingLockKHR(VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo) { + Timer timer("vkAcquireProfilingLockKHR"); + VkResult result = device_dispatch_table(device)->AcquireProfilingLockKHR(device, pInfo); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkReleaseProfilingLockKHR(VkDevice device) { + Timer timer("vkReleaseProfilingLockKHR"); + device_dispatch_table(device)->ReleaseProfilingLockKHR(device); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + Timer timer("vkGetImageMemoryRequirements2KHR"); + device_dispatch_table(device)->GetImageMemoryRequirements2KHR(device, pInfo, pMemoryRequirements); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + Timer timer("vkGetBufferMemoryRequirements2KHR"); + device_dispatch_table(device)->GetBufferMemoryRequirements2KHR(device, pInfo, pMemoryRequirements); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2KHR(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { + Timer timer("vkGetImageSparseMemoryRequirements2KHR"); + device_dispatch_table(device)->GetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversionKHR(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) { + Timer timer("vkCreateSamplerYcbcrConversionKHR"); + VkResult result = device_dispatch_table(device)->CreateSamplerYcbcrConversionKHR(device, pCreateInfo, pAllocator, pYcbcrConversion); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroySamplerYcbcrConversionKHR"); + device_dispatch_table(device)->DestroySamplerYcbcrConversionKHR(device, ycbcrConversion, pAllocator); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) { + Timer timer("vkBindBufferMemory2KHR"); + VkResult result = device_dispatch_table(device)->BindBufferMemory2KHR(device, bindInfoCount, pBindInfos); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) { + Timer timer("vkBindImageMemory2KHR"); + VkResult result = device_dispatch_table(device)->BindImageMemory2KHR(device, bindInfoCount, pBindInfos); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupportKHR(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) { + Timer timer("vkGetDescriptorSetLayoutSupportKHR"); + device_dispatch_table(device)->GetDescriptorSetLayoutSupportKHR(device, pCreateInfo, pSupport); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { + Timer timer("vkCmdDrawIndirectCountKHR"); + device_dispatch_table(commandBuffer)->CmdDrawIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { + Timer timer("vkCmdDrawIndexedIndirectCountKHR"); + device_dispatch_table(commandBuffer)->CmdDrawIndexedIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore, uint64_t* pValue) { + Timer timer("vkGetSemaphoreCounterValueKHR"); + VkResult result = device_dispatch_table(device)->GetSemaphoreCounterValueKHR(device, semaphore, pValue); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkWaitSemaphoresKHR(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout) { + Timer timer("vkWaitSemaphoresKHR"); + VkResult result = device_dispatch_table(device)->WaitSemaphoresKHR(device, pWaitInfo, timeout); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkSignalSemaphoreKHR(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) { + Timer timer("vkSignalSemaphoreKHR"); + VkResult result = device_dispatch_table(device)->SignalSemaphoreKHR(device, pSignalInfo); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) { + Timer timer("vkCmdSetFragmentShadingRateKHR"); + device_dispatch_table(commandBuffer)->CmdSetFragmentShadingRateKHR(commandBuffer, pFragmentSize, combinerOps); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetRenderingAttachmentLocationsKHR(VkCommandBuffer commandBuffer, const VkRenderingAttachmentLocationInfo* pLocationInfo) { + Timer timer("vkCmdSetRenderingAttachmentLocationsKHR"); + device_dispatch_table(commandBuffer)->CmdSetRenderingAttachmentLocationsKHR(commandBuffer, pLocationInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetRenderingInputAttachmentIndicesKHR(VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo) { + Timer timer("vkCmdSetRenderingInputAttachmentIndicesKHR"); + device_dispatch_table(commandBuffer)->CmdSetRenderingInputAttachmentIndicesKHR(commandBuffer, pInputAttachmentIndexInfo); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkWaitForPresentKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout) { + Timer timer("vkWaitForPresentKHR"); + VkResult result = device_dispatch_table(device)->WaitForPresentKHR(device, swapchain, presentId, timeout); + return result; +} +template +VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) { + Timer timer("vkGetBufferDeviceAddressKHR"); + VkDeviceAddress result = device_dispatch_table(device)->GetBufferDeviceAddressKHR(device, pInfo); + return result; +} +template +VKAPI_ATTR uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) { + Timer timer("vkGetBufferOpaqueCaptureAddressKHR"); + uint64_t result = device_dispatch_table(device)->GetBufferOpaqueCaptureAddressKHR(device, pInfo); + return result; +} +template +VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddressKHR(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) { + Timer timer("vkGetDeviceMemoryOpaqueCaptureAddressKHR"); + uint64_t result = device_dispatch_table(device)->GetDeviceMemoryOpaqueCaptureAddressKHR(device, pInfo); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDeferredOperationKHR(VkDevice device, const VkAllocationCallbacks* pAllocator, VkDeferredOperationKHR* pDeferredOperation) { + Timer timer("vkCreateDeferredOperationKHR"); + VkResult result = device_dispatch_table(device)->CreateDeferredOperationKHR(device, pAllocator, pDeferredOperation); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyDeferredOperationKHR(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyDeferredOperationKHR"); + device_dispatch_table(device)->DestroyDeferredOperationKHR(device, operation, pAllocator); +} +template +VKAPI_ATTR uint32_t VKAPI_CALL vkGetDeferredOperationMaxConcurrencyKHR(VkDevice device, VkDeferredOperationKHR operation) { + Timer timer("vkGetDeferredOperationMaxConcurrencyKHR"); + uint32_t result = device_dispatch_table(device)->GetDeferredOperationMaxConcurrencyKHR(device, operation); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetDeferredOperationResultKHR(VkDevice device, VkDeferredOperationKHR operation) { + Timer timer("vkGetDeferredOperationResultKHR"); + VkResult result = device_dispatch_table(device)->GetDeferredOperationResultKHR(device, operation); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkDeferredOperationJoinKHR(VkDevice device, VkDeferredOperationKHR operation) { + Timer timer("vkDeferredOperationJoinKHR"); + VkResult result = device_dispatch_table(device)->DeferredOperationJoinKHR(device, operation); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutablePropertiesKHR(VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties) { + Timer timer("vkGetPipelineExecutablePropertiesKHR"); + VkResult result = device_dispatch_table(device)->GetPipelineExecutablePropertiesKHR(device, pPipelineInfo, pExecutableCount, pProperties); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableStatisticsKHR(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics) { + Timer timer("vkGetPipelineExecutableStatisticsKHR"); + VkResult result = device_dispatch_table(device)->GetPipelineExecutableStatisticsKHR(device, pExecutableInfo, pStatisticCount, pStatistics); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableInternalRepresentationsKHR(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) { + Timer timer("vkGetPipelineExecutableInternalRepresentationsKHR"); + VkResult result = device_dispatch_table(device)->GetPipelineExecutableInternalRepresentationsKHR(device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory2KHR(VkDevice device, const VkMemoryMapInfo* pMemoryMapInfo, void** ppData) { + Timer timer("vkMapMemory2KHR"); + VkResult result = device_dispatch_table(device)->MapMemory2KHR(device, pMemoryMapInfo, ppData); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkUnmapMemory2KHR(VkDevice device, const VkMemoryUnmapInfo* pMemoryUnmapInfo) { + Timer timer("vkUnmapMemory2KHR"); + VkResult result = device_dispatch_table(device)->UnmapMemory2KHR(device, pMemoryUnmapInfo); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetEncodedVideoSessionParametersKHR(VkDevice device, const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, size_t* pDataSize, void* pData) { + Timer timer("vkGetEncodedVideoSessionParametersKHR"); + VkResult result = device_dispatch_table(device)->GetEncodedVideoSessionParametersKHR(device, pVideoSessionParametersInfo, pFeedbackInfo, pDataSize, pData); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdEncodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo) { + Timer timer("vkCmdEncodeVideoKHR"); + device_dispatch_table(commandBuffer)->CmdEncodeVideoKHR(commandBuffer, pEncodeInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) { + Timer timer("vkCmdSetEvent2KHR"); + device_dispatch_table(commandBuffer)->CmdSetEvent2KHR(commandBuffer, event, pDependencyInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) { + Timer timer("vkCmdResetEvent2KHR"); + device_dispatch_table(commandBuffer)->CmdResetEvent2KHR(commandBuffer, event, stageMask); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) { + Timer timer("vkCmdWaitEvents2KHR"); + device_dispatch_table(commandBuffer)->CmdWaitEvents2KHR(commandBuffer, eventCount, pEvents, pDependencyInfos); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) { + Timer timer("vkCmdPipelineBarrier2KHR"); + device_dispatch_table(commandBuffer)->CmdPipelineBarrier2KHR(commandBuffer, pDependencyInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) { + Timer timer("vkCmdWriteTimestamp2KHR"); + device_dispatch_table(commandBuffer)->CmdWriteTimestamp2KHR(commandBuffer, stage, queryPool, query); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit2KHR(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence) { + Timer timer("vkQueueSubmit2KHR"); + VkResult result = device_dispatch_table(queue)->QueueSubmit2KHR(queue, submitCount, pSubmits, fence); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) { + Timer timer("vkCmdCopyBuffer2KHR"); + device_dispatch_table(commandBuffer)->CmdCopyBuffer2KHR(commandBuffer, pCopyBufferInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) { + Timer timer("vkCmdCopyImage2KHR"); + device_dispatch_table(commandBuffer)->CmdCopyImage2KHR(commandBuffer, pCopyImageInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) { + Timer timer("vkCmdCopyBufferToImage2KHR"); + device_dispatch_table(commandBuffer)->CmdCopyBufferToImage2KHR(commandBuffer, pCopyBufferToImageInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) { + Timer timer("vkCmdCopyImageToBuffer2KHR"); + device_dispatch_table(commandBuffer)->CmdCopyImageToBuffer2KHR(commandBuffer, pCopyImageToBufferInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) { + Timer timer("vkCmdBlitImage2KHR"); + device_dispatch_table(commandBuffer)->CmdBlitImage2KHR(commandBuffer, pBlitImageInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo) { + Timer timer("vkCmdResolveImage2KHR"); + device_dispatch_table(commandBuffer)->CmdResolveImage2KHR(commandBuffer, pResolveImageInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysIndirect2KHR(VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress) { + Timer timer("vkCmdTraceRaysIndirect2KHR"); + device_dispatch_table(commandBuffer)->CmdTraceRaysIndirect2KHR(commandBuffer, indirectDeviceAddress); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetDeviceBufferMemoryRequirementsKHR(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + Timer timer("vkGetDeviceBufferMemoryRequirementsKHR"); + device_dispatch_table(device)->GetDeviceBufferMemoryRequirementsKHR(device, pInfo, pMemoryRequirements); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageMemoryRequirementsKHR(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + Timer timer("vkGetDeviceImageMemoryRequirementsKHR"); + device_dispatch_table(device)->GetDeviceImageMemoryRequirementsKHR(device, pInfo, pMemoryRequirements); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSparseMemoryRequirementsKHR(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { + Timer timer("vkGetDeviceImageSparseMemoryRequirementsKHR"); + device_dispatch_table(device)->GetDeviceImageSparseMemoryRequirementsKHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer2KHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType) { + Timer timer("vkCmdBindIndexBuffer2KHR"); + device_dispatch_table(commandBuffer)->CmdBindIndexBuffer2KHR(commandBuffer, buffer, offset, size, indexType); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetRenderingAreaGranularityKHR(VkDevice device, const VkRenderingAreaInfo* pRenderingAreaInfo, VkExtent2D* pGranularity) { + Timer timer("vkGetRenderingAreaGranularityKHR"); + device_dispatch_table(device)->GetRenderingAreaGranularityKHR(device, pRenderingAreaInfo, pGranularity); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSubresourceLayoutKHR(VkDevice device, const VkDeviceImageSubresourceInfo* pInfo, VkSubresourceLayout2* pLayout) { + Timer timer("vkGetDeviceImageSubresourceLayoutKHR"); + device_dispatch_table(device)->GetDeviceImageSubresourceLayoutKHR(device, pInfo, pLayout); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout2KHR(VkDevice device, VkImage image, const VkImageSubresource2* pSubresource, VkSubresourceLayout2* pLayout) { + Timer timer("vkGetImageSubresourceLayout2KHR"); + device_dispatch_table(device)->GetImageSubresourceLayout2KHR(device, image, pSubresource, pLayout); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkWaitForPresent2KHR(VkDevice device, VkSwapchainKHR swapchain, const VkPresentWait2InfoKHR* pPresentWait2Info) { + Timer timer("vkWaitForPresent2KHR"); + VkResult result = device_dispatch_table(device)->WaitForPresent2KHR(device, swapchain, pPresentWait2Info); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineBinariesKHR(VkDevice device, const VkPipelineBinaryCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineBinaryHandlesInfoKHR* pBinaries) { + Timer timer("vkCreatePipelineBinariesKHR"); + VkResult result = device_dispatch_table(device)->CreatePipelineBinariesKHR(device, pCreateInfo, pAllocator, pBinaries); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineBinaryKHR(VkDevice device, VkPipelineBinaryKHR pipelineBinary, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyPipelineBinaryKHR"); + device_dispatch_table(device)->DestroyPipelineBinaryKHR(device, pipelineBinary, pAllocator); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineKeyKHR(VkDevice device, const VkPipelineCreateInfoKHR* pPipelineCreateInfo, VkPipelineBinaryKeyKHR* pPipelineKey) { + Timer timer("vkGetPipelineKeyKHR"); + VkResult result = device_dispatch_table(device)->GetPipelineKeyKHR(device, pPipelineCreateInfo, pPipelineKey); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineBinaryDataKHR(VkDevice device, const VkPipelineBinaryDataInfoKHR* pInfo, VkPipelineBinaryKeyKHR* pPipelineBinaryKey, size_t* pPipelineBinaryDataSize, void* pPipelineBinaryData) { + Timer timer("vkGetPipelineBinaryDataKHR"); + VkResult result = device_dispatch_table(device)->GetPipelineBinaryDataKHR(device, pInfo, pPipelineBinaryKey, pPipelineBinaryDataSize, pPipelineBinaryData); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkReleaseCapturedPipelineDataKHR(VkDevice device, const VkReleaseCapturedPipelineDataInfoKHR* pInfo, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkReleaseCapturedPipelineDataKHR"); + VkResult result = device_dispatch_table(device)->ReleaseCapturedPipelineDataKHR(device, pInfo, pAllocator); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkReleaseSwapchainImagesKHR(VkDevice device, const VkReleaseSwapchainImagesInfoKHR* pReleaseInfo) { + Timer timer("vkReleaseSwapchainImagesKHR"); + VkResult result = device_dispatch_table(device)->ReleaseSwapchainImagesKHR(device, pReleaseInfo); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleKHR(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) { + Timer timer("vkCmdSetLineStippleKHR"); + device_dispatch_table(commandBuffer)->CmdSetLineStippleKHR(commandBuffer, lineStippleFactor, lineStipplePattern); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetCalibratedTimestampsKHR(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation) { + Timer timer("vkGetCalibratedTimestampsKHR"); + VkResult result = device_dispatch_table(device)->GetCalibratedTimestampsKHR(device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets2KHR(VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo) { + Timer timer("vkCmdBindDescriptorSets2KHR"); + device_dispatch_table(commandBuffer)->CmdBindDescriptorSets2KHR(commandBuffer, pBindDescriptorSetsInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants2KHR(VkCommandBuffer commandBuffer, const VkPushConstantsInfo* pPushConstantsInfo) { + Timer timer("vkCmdPushConstants2KHR"); + device_dispatch_table(commandBuffer)->CmdPushConstants2KHR(commandBuffer, pPushConstantsInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSet2KHR(VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfo* pPushDescriptorSetInfo) { + Timer timer("vkCmdPushDescriptorSet2KHR"); + device_dispatch_table(commandBuffer)->CmdPushDescriptorSet2KHR(commandBuffer, pPushDescriptorSetInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplate2KHR(VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo) { + Timer timer("vkCmdPushDescriptorSetWithTemplate2KHR"); + device_dispatch_table(commandBuffer)->CmdPushDescriptorSetWithTemplate2KHR(commandBuffer, pPushDescriptorSetWithTemplateInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetDescriptorBufferOffsets2EXT(VkCommandBuffer commandBuffer, const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo) { + Timer timer("vkCmdSetDescriptorBufferOffsets2EXT"); + device_dispatch_table(commandBuffer)->CmdSetDescriptorBufferOffsets2EXT(commandBuffer, pSetDescriptorBufferOffsetsInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo) { + Timer timer("vkCmdBindDescriptorBufferEmbeddedSamplers2EXT"); + device_dispatch_table(commandBuffer)->CmdBindDescriptorBufferEmbeddedSamplers2EXT(commandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryIndirectKHR(VkCommandBuffer commandBuffer, const VkCopyMemoryIndirectInfoKHR* pCopyMemoryIndirectInfo) { + Timer timer("vkCmdCopyMemoryIndirectKHR"); + device_dispatch_table(commandBuffer)->CmdCopyMemoryIndirectKHR(commandBuffer, pCopyMemoryIndirectInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToImageIndirectKHR(VkCommandBuffer commandBuffer, const VkCopyMemoryToImageIndirectInfoKHR* pCopyMemoryToImageIndirectInfo) { + Timer timer("vkCmdCopyMemoryToImageIndirectKHR"); + device_dispatch_table(commandBuffer)->CmdCopyMemoryToImageIndirectKHR(commandBuffer, pCopyMemoryToImageIndirectInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdEndRendering2KHR(VkCommandBuffer commandBuffer, const VkRenderingEndInfoKHR* pRenderingEndInfo) { + Timer timer("vkCmdEndRendering2KHR"); + device_dispatch_table(commandBuffer)->CmdEndRendering2KHR(commandBuffer, pRenderingEndInfo); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo) { + Timer timer("vkDebugMarkerSetObjectTagEXT"); + VkResult result = device_dispatch_table(device)->DebugMarkerSetObjectTagEXT(device, pTagInfo); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo) { + Timer timer("vkDebugMarkerSetObjectNameEXT"); + VkResult result = device_dispatch_table(device)->DebugMarkerSetObjectNameEXT(device, pNameInfo); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) { + Timer timer("vkCmdDebugMarkerBeginEXT"); + device_dispatch_table(commandBuffer)->CmdDebugMarkerBeginEXT(commandBuffer, pMarkerInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer) { + Timer timer("vkCmdDebugMarkerEndEXT"); + device_dispatch_table(commandBuffer)->CmdDebugMarkerEndEXT(commandBuffer); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) { + Timer timer("vkCmdDebugMarkerInsertEXT"); + device_dispatch_table(commandBuffer)->CmdDebugMarkerInsertEXT(commandBuffer, pMarkerInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes) { + Timer timer("vkCmdBindTransformFeedbackBuffersEXT"); + device_dispatch_table(commandBuffer)->CmdBindTransformFeedbackBuffersEXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) { + Timer timer("vkCmdBeginTransformFeedbackEXT"); + device_dispatch_table(commandBuffer)->CmdBeginTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) { + Timer timer("vkCmdEndTransformFeedbackEXT"); + device_dispatch_table(commandBuffer)->CmdEndTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index) { + Timer timer("vkCmdBeginQueryIndexedEXT"); + device_dispatch_table(commandBuffer)->CmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index) { + Timer timer("vkCmdEndQueryIndexedEXT"); + device_dispatch_table(commandBuffer)->CmdEndQueryIndexedEXT(commandBuffer, queryPool, query, index); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride) { + Timer timer("vkCmdDrawIndirectByteCountEXT"); + device_dispatch_table(commandBuffer)->CmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateCuModuleNVX(VkDevice device, const VkCuModuleCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuModuleNVX* pModule) { + Timer timer("vkCreateCuModuleNVX"); + VkResult result = device_dispatch_table(device)->CreateCuModuleNVX(device, pCreateInfo, pAllocator, pModule); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateCuFunctionNVX(VkDevice device, const VkCuFunctionCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuFunctionNVX* pFunction) { + Timer timer("vkCreateCuFunctionNVX"); + VkResult result = device_dispatch_table(device)->CreateCuFunctionNVX(device, pCreateInfo, pAllocator, pFunction); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyCuModuleNVX(VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyCuModuleNVX"); + device_dispatch_table(device)->DestroyCuModuleNVX(device, module, pAllocator); +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyCuFunctionNVX(VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyCuFunctionNVX"); + device_dispatch_table(device)->DestroyCuFunctionNVX(device, function, pAllocator); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdCuLaunchKernelNVX(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo) { + Timer timer("vkCmdCuLaunchKernelNVX"); + device_dispatch_table(commandBuffer)->CmdCuLaunchKernelNVX(commandBuffer, pLaunchInfo); +} +template +VKAPI_ATTR uint32_t VKAPI_CALL vkGetImageViewHandleNVX(VkDevice device, const VkImageViewHandleInfoNVX* pInfo) { + Timer timer("vkGetImageViewHandleNVX"); + uint32_t result = device_dispatch_table(device)->GetImageViewHandleNVX(device, pInfo); + return result; +} +template +VKAPI_ATTR uint64_t VKAPI_CALL vkGetImageViewHandle64NVX(VkDevice device, const VkImageViewHandleInfoNVX* pInfo) { + Timer timer("vkGetImageViewHandle64NVX"); + uint64_t result = device_dispatch_table(device)->GetImageViewHandle64NVX(device, pInfo); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetImageViewAddressNVX(VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX* pProperties) { + Timer timer("vkGetImageViewAddressNVX"); + VkResult result = device_dispatch_table(device)->GetImageViewAddressNVX(device, imageView, pProperties); + return result; +} +template +VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceCombinedImageSamplerIndexNVX(VkDevice device, uint64_t imageViewIndex, uint64_t samplerIndex) { + Timer timer("vkGetDeviceCombinedImageSamplerIndexNVX"); + uint64_t result = device_dispatch_table(device)->GetDeviceCombinedImageSamplerIndexNVX(device, imageViewIndex, samplerIndex); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { + Timer timer("vkCmdDrawIndirectCountAMD"); + device_dispatch_table(commandBuffer)->CmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { + Timer timer("vkCmdDrawIndexedIndirectCountAMD"); + device_dispatch_table(commandBuffer)->CmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo) { + Timer timer("vkGetShaderInfoAMD"); + VkResult result = device_dispatch_table(device)->GetShaderInfoAMD(device, pipeline, shaderStage, infoType, pInfoSize, pInfo); + return result; +} +#if defined(VK_USE_PLATFORM_WIN32_KHR) +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle) { + Timer timer("vkGetMemoryWin32HandleNV"); + VkResult result = device_dispatch_table(device)->GetMemoryWin32HandleNV(device, memory, handleType, pHandle); + return result; +} +#endif // VK_USE_PLATFORM_WIN32_KHR +template +VKAPI_ATTR void VKAPI_CALL vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) { + Timer timer("vkCmdBeginConditionalRenderingEXT"); + device_dispatch_table(commandBuffer)->CmdBeginConditionalRenderingEXT(commandBuffer, pConditionalRenderingBegin); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer) { + Timer timer("vkCmdEndConditionalRenderingEXT"); + device_dispatch_table(commandBuffer)->CmdEndConditionalRenderingEXT(commandBuffer); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings) { + Timer timer("vkCmdSetViewportWScalingNV"); + device_dispatch_table(commandBuffer)->CmdSetViewportWScalingNV(commandBuffer, firstViewport, viewportCount, pViewportWScalings); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkDisplayPowerControlEXT(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo) { + Timer timer("vkDisplayPowerControlEXT"); + VkResult result = device_dispatch_table(device)->DisplayPowerControlEXT(device, display, pDisplayPowerInfo); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDeviceEventEXT(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) { + Timer timer("vkRegisterDeviceEventEXT"); + VkResult result = device_dispatch_table(device)->RegisterDeviceEventEXT(device, pDeviceEventInfo, pAllocator, pFence); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDisplayEventEXT(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) { + Timer timer("vkRegisterDisplayEventEXT"); + VkResult result = device_dispatch_table(device)->RegisterDisplayEventEXT(device, display, pDisplayEventInfo, pAllocator, pFence); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainCounterEXT(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue) { + Timer timer("vkGetSwapchainCounterEXT"); + VkResult result = device_dispatch_table(device)->GetSwapchainCounterEXT(device, swapchain, counter, pCounterValue); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetRefreshCycleDurationGOOGLE(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) { + Timer timer("vkGetRefreshCycleDurationGOOGLE"); + VkResult result = device_dispatch_table(device)->GetRefreshCycleDurationGOOGLE(device, swapchain, pDisplayTimingProperties); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetPastPresentationTimingGOOGLE(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings) { + Timer timer("vkGetPastPresentationTimingGOOGLE"); + VkResult result = device_dispatch_table(device)->GetPastPresentationTimingGOOGLE(device, swapchain, pPresentationTimingCount, pPresentationTimings); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles) { + Timer timer("vkCmdSetDiscardRectangleEXT"); + device_dispatch_table(commandBuffer)->CmdSetDiscardRectangleEXT(commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable) { + Timer timer("vkCmdSetDiscardRectangleEnableEXT"); + device_dispatch_table(commandBuffer)->CmdSetDiscardRectangleEnableEXT(commandBuffer, discardRectangleEnable); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleModeEXT(VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode) { + Timer timer("vkCmdSetDiscardRectangleModeEXT"); + device_dispatch_table(commandBuffer)->CmdSetDiscardRectangleModeEXT(commandBuffer, discardRectangleMode); +} +template +VKAPI_ATTR void VKAPI_CALL vkSetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata) { + Timer timer("vkSetHdrMetadataEXT"); + device_dispatch_table(device)->SetHdrMetadataEXT(device, swapchainCount, pSwapchains, pMetadata); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo) { + Timer timer("vkSetDebugUtilsObjectNameEXT"); + VkResult result = device_dispatch_table(device)->SetDebugUtilsObjectNameEXT(device, pNameInfo); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo) { + Timer timer("vkSetDebugUtilsObjectTagEXT"); + VkResult result = device_dispatch_table(device)->SetDebugUtilsObjectTagEXT(device, pTagInfo); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) { + Timer timer("vkQueueBeginDebugUtilsLabelEXT"); + device_dispatch_table(queue)->QueueBeginDebugUtilsLabelEXT(queue, pLabelInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkQueueEndDebugUtilsLabelEXT(VkQueue queue) { + Timer timer("vkQueueEndDebugUtilsLabelEXT"); + device_dispatch_table(queue)->QueueEndDebugUtilsLabelEXT(queue); +} +template +VKAPI_ATTR void VKAPI_CALL vkQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) { + Timer timer("vkQueueInsertDebugUtilsLabelEXT"); + device_dispatch_table(queue)->QueueInsertDebugUtilsLabelEXT(queue, pLabelInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) { + Timer timer("vkCmdBeginDebugUtilsLabelEXT"); + device_dispatch_table(commandBuffer)->CmdBeginDebugUtilsLabelEXT(commandBuffer, pLabelInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer) { + Timer timer("vkCmdEndDebugUtilsLabelEXT"); + device_dispatch_table(commandBuffer)->CmdEndDebugUtilsLabelEXT(commandBuffer); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) { + Timer timer("vkCmdInsertDebugUtilsLabelEXT"); + device_dispatch_table(commandBuffer)->CmdInsertDebugUtilsLabelEXT(commandBuffer, pLabelInfo); +} +#if defined(VK_USE_PLATFORM_ANDROID_KHR) +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetAndroidHardwareBufferPropertiesANDROID(VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties) { + Timer timer("vkGetAndroidHardwareBufferPropertiesANDROID"); + VkResult result = device_dispatch_table(device)->GetAndroidHardwareBufferPropertiesANDROID(device, buffer, pProperties); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryAndroidHardwareBufferANDROID(VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer) { + Timer timer("vkGetMemoryAndroidHardwareBufferANDROID"); + VkResult result = device_dispatch_table(device)->GetMemoryAndroidHardwareBufferANDROID(device, pInfo, pBuffer); + return result; +} +#endif // VK_USE_PLATFORM_ANDROID_KHR +#if defined(VK_ENABLE_BETA_EXTENSIONS) +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateExecutionGraphPipelinesAMDX(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkExecutionGraphPipelineCreateInfoAMDX* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { + Timer timer("vkCreateExecutionGraphPipelinesAMDX"); + VkResult result = device_dispatch_table(device)->CreateExecutionGraphPipelinesAMDX(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetExecutionGraphPipelineScratchSizeAMDX(VkDevice device, VkPipeline executionGraph, VkExecutionGraphPipelineScratchSizeAMDX* pSizeInfo) { + Timer timer("vkGetExecutionGraphPipelineScratchSizeAMDX"); + VkResult result = device_dispatch_table(device)->GetExecutionGraphPipelineScratchSizeAMDX(device, executionGraph, pSizeInfo); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetExecutionGraphPipelineNodeIndexAMDX(VkDevice device, VkPipeline executionGraph, const VkPipelineShaderStageNodeCreateInfoAMDX* pNodeInfo, uint32_t* pNodeIndex) { + Timer timer("vkGetExecutionGraphPipelineNodeIndexAMDX"); + VkResult result = device_dispatch_table(device)->GetExecutionGraphPipelineNodeIndexAMDX(device, executionGraph, pNodeInfo, pNodeIndex); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdInitializeGraphScratchMemoryAMDX(VkCommandBuffer commandBuffer, VkPipeline executionGraph, VkDeviceAddress scratch, VkDeviceSize scratchSize) { + Timer timer("vkCmdInitializeGraphScratchMemoryAMDX"); + device_dispatch_table(commandBuffer)->CmdInitializeGraphScratchMemoryAMDX(commandBuffer, executionGraph, scratch, scratchSize); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchGraphAMDX(VkCommandBuffer commandBuffer, VkDeviceAddress scratch, VkDeviceSize scratchSize, const VkDispatchGraphCountInfoAMDX* pCountInfo) { + Timer timer("vkCmdDispatchGraphAMDX"); + device_dispatch_table(commandBuffer)->CmdDispatchGraphAMDX(commandBuffer, scratch, scratchSize, pCountInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchGraphIndirectAMDX(VkCommandBuffer commandBuffer, VkDeviceAddress scratch, VkDeviceSize scratchSize, const VkDispatchGraphCountInfoAMDX* pCountInfo) { + Timer timer("vkCmdDispatchGraphIndirectAMDX"); + device_dispatch_table(commandBuffer)->CmdDispatchGraphIndirectAMDX(commandBuffer, scratch, scratchSize, pCountInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchGraphIndirectCountAMDX(VkCommandBuffer commandBuffer, VkDeviceAddress scratch, VkDeviceSize scratchSize, VkDeviceAddress countInfo) { + Timer timer("vkCmdDispatchGraphIndirectCountAMDX"); + device_dispatch_table(commandBuffer)->CmdDispatchGraphIndirectCountAMDX(commandBuffer, scratch, scratchSize, countInfo); +} +#endif // VK_ENABLE_BETA_EXTENSIONS +template +VKAPI_ATTR VkResult VKAPI_CALL vkWriteSamplerDescriptorsEXT(VkDevice device, uint32_t samplerCount, const VkSamplerCreateInfo* pSamplers, const VkHostAddressRangeEXT* pDescriptors) { + Timer timer("vkWriteSamplerDescriptorsEXT"); + VkResult result = device_dispatch_table(device)->WriteSamplerDescriptorsEXT(device, samplerCount, pSamplers, pDescriptors); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkWriteResourceDescriptorsEXT(VkDevice device, uint32_t resourceCount, const VkResourceDescriptorInfoEXT* pResources, const VkHostAddressRangeEXT* pDescriptors) { + Timer timer("vkWriteResourceDescriptorsEXT"); + VkResult result = device_dispatch_table(device)->WriteResourceDescriptorsEXT(device, resourceCount, pResources, pDescriptors); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdBindSamplerHeapEXT(VkCommandBuffer commandBuffer, const VkBindHeapInfoEXT* pBindInfo) { + Timer timer("vkCmdBindSamplerHeapEXT"); + device_dispatch_table(commandBuffer)->CmdBindSamplerHeapEXT(commandBuffer, pBindInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdBindResourceHeapEXT(VkCommandBuffer commandBuffer, const VkBindHeapInfoEXT* pBindInfo) { + Timer timer("vkCmdBindResourceHeapEXT"); + device_dispatch_table(commandBuffer)->CmdBindResourceHeapEXT(commandBuffer, pBindInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdPushDataEXT(VkCommandBuffer commandBuffer, const VkPushDataInfoEXT* pPushDataInfo) { + Timer timer("vkCmdPushDataEXT"); + device_dispatch_table(commandBuffer)->CmdPushDataEXT(commandBuffer, pPushDataInfo); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetImageOpaqueCaptureDataEXT(VkDevice device, uint32_t imageCount, const VkImage* pImages, VkHostAddressRangeEXT* pDatas) { + Timer timer("vkGetImageOpaqueCaptureDataEXT"); + VkResult result = device_dispatch_table(device)->GetImageOpaqueCaptureDataEXT(device, imageCount, pImages, pDatas); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkRegisterCustomBorderColorEXT(VkDevice device, const VkSamplerCustomBorderColorCreateInfoEXT* pBorderColor, VkBool32 requestIndex, uint32_t* pIndex) { + Timer timer("vkRegisterCustomBorderColorEXT"); + VkResult result = device_dispatch_table(device)->RegisterCustomBorderColorEXT(device, pBorderColor, requestIndex, pIndex); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkUnregisterCustomBorderColorEXT(VkDevice device, uint32_t index) { + Timer timer("vkUnregisterCustomBorderColorEXT"); + device_dispatch_table(device)->UnregisterCustomBorderColorEXT(device, index); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetTensorOpaqueCaptureDataARM(VkDevice device, uint32_t tensorCount, const VkTensorARM* pTensors, VkHostAddressRangeEXT* pDatas) { + Timer timer("vkGetTensorOpaqueCaptureDataARM"); + VkResult result = device_dispatch_table(device)->GetTensorOpaqueCaptureDataARM(device, tensorCount, pTensors, pDatas); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo) { + Timer timer("vkCmdSetSampleLocationsEXT"); + device_dispatch_table(commandBuffer)->CmdSetSampleLocationsEXT(commandBuffer, pSampleLocationsInfo); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties) { + Timer timer("vkGetImageDrmFormatModifierPropertiesEXT"); + VkResult result = device_dispatch_table(device)->GetImageDrmFormatModifierPropertiesEXT(device, image, pProperties); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateValidationCacheEXT(VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache) { + Timer timer("vkCreateValidationCacheEXT"); + VkResult result = device_dispatch_table(device)->CreateValidationCacheEXT(device, pCreateInfo, pAllocator, pValidationCache); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyValidationCacheEXT"); + device_dispatch_table(device)->DestroyValidationCacheEXT(device, validationCache, pAllocator); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkMergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches) { + Timer timer("vkMergeValidationCachesEXT"); + VkResult result = device_dispatch_table(device)->MergeValidationCachesEXT(device, dstCache, srcCacheCount, pSrcCaches); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData) { + Timer timer("vkGetValidationCacheDataEXT"); + VkResult result = device_dispatch_table(device)->GetValidationCacheDataEXT(device, validationCache, pDataSize, pData); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) { + Timer timer("vkCmdBindShadingRateImageNV"); + device_dispatch_table(commandBuffer)->CmdBindShadingRateImageNV(commandBuffer, imageView, imageLayout); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes) { + Timer timer("vkCmdSetViewportShadingRatePaletteNV"); + device_dispatch_table(commandBuffer)->CmdSetViewportShadingRatePaletteNV(commandBuffer, firstViewport, viewportCount, pShadingRatePalettes); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders) { + Timer timer("vkCmdSetCoarseSampleOrderNV"); + device_dispatch_table(commandBuffer)->CmdSetCoarseSampleOrderNV(commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateAccelerationStructureNV(VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure) { + Timer timer("vkCreateAccelerationStructureNV"); + VkResult result = device_dispatch_table(device)->CreateAccelerationStructureNV(device, pCreateInfo, pAllocator, pAccelerationStructure); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyAccelerationStructureNV"); + device_dispatch_table(device)->DestroyAccelerationStructureNV(device, accelerationStructure, pAllocator); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureMemoryRequirementsNV(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements) { + Timer timer("vkGetAccelerationStructureMemoryRequirementsNV"); + device_dispatch_table(device)->GetAccelerationStructureMemoryRequirementsNV(device, pInfo, pMemoryRequirements); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkBindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos) { + Timer timer("vkBindAccelerationStructureMemoryNV"); + VkResult result = device_dispatch_table(device)->BindAccelerationStructureMemoryNV(device, bindInfoCount, pBindInfos); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset) { + Timer timer("vkCmdBuildAccelerationStructureNV"); + device_dispatch_table(commandBuffer)->CmdBuildAccelerationStructureNV(commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode) { + Timer timer("vkCmdCopyAccelerationStructureNV"); + device_dispatch_table(commandBuffer)->CmdCopyAccelerationStructureNV(commandBuffer, dst, src, mode); +} +template +VKAPI_ATTR void VKAPI_CALL 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) { + Timer timer("vkCmdTraceRaysNV"); + device_dispatch_table(commandBuffer)->CmdTraceRaysNV(commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { + Timer timer("vkCreateRayTracingPipelinesNV"); + VkResult result = device_dispatch_table(device)->CreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) { + Timer timer("vkGetRayTracingShaderGroupHandlesKHR"); + VkResult result = device_dispatch_table(device)->GetRayTracingShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount, dataSize, pData); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) { + Timer timer("vkGetRayTracingShaderGroupHandlesNV"); + VkResult result = device_dispatch_table(device)->GetRayTracingShaderGroupHandlesNV(device, pipeline, firstGroup, groupCount, dataSize, pData); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetAccelerationStructureHandleNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData) { + Timer timer("vkGetAccelerationStructureHandleNV"); + VkResult result = device_dispatch_table(device)->GetAccelerationStructureHandleNV(device, accelerationStructure, dataSize, pData); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) { + Timer timer("vkCmdWriteAccelerationStructuresPropertiesNV"); + device_dispatch_table(commandBuffer)->CmdWriteAccelerationStructuresPropertiesNV(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader) { + Timer timer("vkCompileDeferredNV"); + VkResult result = device_dispatch_table(device)->CompileDeferredNV(device, pipeline, shader); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) { + Timer timer("vkGetMemoryHostPointerPropertiesEXT"); + VkResult result = device_dispatch_table(device)->GetMemoryHostPointerPropertiesEXT(device, handleType, pHostPointer, pMemoryHostPointerProperties); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) { + Timer timer("vkCmdWriteBufferMarkerAMD"); + device_dispatch_table(commandBuffer)->CmdWriteBufferMarkerAMD(commandBuffer, pipelineStage, dstBuffer, dstOffset, marker); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) { + Timer timer("vkCmdWriteBufferMarker2AMD"); + device_dispatch_table(commandBuffer)->CmdWriteBufferMarker2AMD(commandBuffer, stage, dstBuffer, dstOffset, marker); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation) { + Timer timer("vkGetCalibratedTimestampsEXT"); + VkResult result = device_dispatch_table(device)->GetCalibratedTimestampsEXT(device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask) { + Timer timer("vkCmdDrawMeshTasksNV"); + device_dispatch_table(commandBuffer)->CmdDrawMeshTasksNV(commandBuffer, taskCount, firstTask); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) { + Timer timer("vkCmdDrawMeshTasksIndirectNV"); + device_dispatch_table(commandBuffer)->CmdDrawMeshTasksIndirectNV(commandBuffer, buffer, offset, drawCount, stride); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { + Timer timer("vkCmdDrawMeshTasksIndirectCountNV"); + device_dispatch_table(commandBuffer)->CmdDrawMeshTasksIndirectCountNV(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetExclusiveScissorEnableNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkBool32* pExclusiveScissorEnables) { + Timer timer("vkCmdSetExclusiveScissorEnableNV"); + device_dispatch_table(commandBuffer)->CmdSetExclusiveScissorEnableNV(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissorEnables); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors) { + Timer timer("vkCmdSetExclusiveScissorNV"); + device_dispatch_table(commandBuffer)->CmdSetExclusiveScissorNV(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void* pCheckpointMarker) { + Timer timer("vkCmdSetCheckpointNV"); + device_dispatch_table(commandBuffer)->CmdSetCheckpointNV(commandBuffer, pCheckpointMarker); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointDataNV(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData) { + Timer timer("vkGetQueueCheckpointDataNV"); + device_dispatch_table(queue)->GetQueueCheckpointDataNV(queue, pCheckpointDataCount, pCheckpointData); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointData2NV(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData) { + Timer timer("vkGetQueueCheckpointData2NV"); + device_dispatch_table(queue)->GetQueueCheckpointData2NV(queue, pCheckpointDataCount, pCheckpointData); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkSetSwapchainPresentTimingQueueSizeEXT(VkDevice device, VkSwapchainKHR swapchain, uint32_t size) { + Timer timer("vkSetSwapchainPresentTimingQueueSizeEXT"); + VkResult result = device_dispatch_table(device)->SetSwapchainPresentTimingQueueSizeEXT(device, swapchain, size); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainTimingPropertiesEXT(VkDevice device, VkSwapchainKHR swapchain, VkSwapchainTimingPropertiesEXT* pSwapchainTimingProperties, uint64_t* pSwapchainTimingPropertiesCounter) { + Timer timer("vkGetSwapchainTimingPropertiesEXT"); + VkResult result = device_dispatch_table(device)->GetSwapchainTimingPropertiesEXT(device, swapchain, pSwapchainTimingProperties, pSwapchainTimingPropertiesCounter); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainTimeDomainPropertiesEXT(VkDevice device, VkSwapchainKHR swapchain, VkSwapchainTimeDomainPropertiesEXT* pSwapchainTimeDomainProperties, uint64_t* pTimeDomainsCounter) { + Timer timer("vkGetSwapchainTimeDomainPropertiesEXT"); + VkResult result = device_dispatch_table(device)->GetSwapchainTimeDomainPropertiesEXT(device, swapchain, pSwapchainTimeDomainProperties, pTimeDomainsCounter); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetPastPresentationTimingEXT(VkDevice device, const VkPastPresentationTimingInfoEXT* pPastPresentationTimingInfo, VkPastPresentationTimingPropertiesEXT* pPastPresentationTimingProperties) { + Timer timer("vkGetPastPresentationTimingEXT"); + VkResult result = device_dispatch_table(device)->GetPastPresentationTimingEXT(device, pPastPresentationTimingInfo, pPastPresentationTimingProperties); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkInitializePerformanceApiINTEL(VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo) { + Timer timer("vkInitializePerformanceApiINTEL"); + VkResult result = device_dispatch_table(device)->InitializePerformanceApiINTEL(device, pInitializeInfo); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkUninitializePerformanceApiINTEL(VkDevice device) { + Timer timer("vkUninitializePerformanceApiINTEL"); + device_dispatch_table(device)->UninitializePerformanceApiINTEL(device); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo) { + Timer timer("vkCmdSetPerformanceMarkerINTEL"); + VkResult result = device_dispatch_table(commandBuffer)->CmdSetPerformanceMarkerINTEL(commandBuffer, pMarkerInfo); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo) { + Timer timer("vkCmdSetPerformanceStreamMarkerINTEL"); + VkResult result = device_dispatch_table(commandBuffer)->CmdSetPerformanceStreamMarkerINTEL(commandBuffer, pMarkerInfo); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo) { + Timer timer("vkCmdSetPerformanceOverrideINTEL"); + VkResult result = device_dispatch_table(commandBuffer)->CmdSetPerformanceOverrideINTEL(commandBuffer, pOverrideInfo); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkAcquirePerformanceConfigurationINTEL(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration) { + Timer timer("vkAcquirePerformanceConfigurationINTEL"); + VkResult result = device_dispatch_table(device)->AcquirePerformanceConfigurationINTEL(device, pAcquireInfo, pConfiguration); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkReleasePerformanceConfigurationINTEL(VkDevice device, VkPerformanceConfigurationINTEL configuration) { + Timer timer("vkReleasePerformanceConfigurationINTEL"); + VkResult result = device_dispatch_table(device)->ReleasePerformanceConfigurationINTEL(device, configuration); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkQueueSetPerformanceConfigurationINTEL(VkQueue queue, VkPerformanceConfigurationINTEL configuration) { + Timer timer("vkQueueSetPerformanceConfigurationINTEL"); + VkResult result = device_dispatch_table(queue)->QueueSetPerformanceConfigurationINTEL(queue, configuration); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue) { + Timer timer("vkGetPerformanceParameterINTEL"); + VkResult result = device_dispatch_table(device)->GetPerformanceParameterINTEL(device, parameter, pValue); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkSetLocalDimmingAMD(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable) { + Timer timer("vkSetLocalDimmingAMD"); + device_dispatch_table(device)->SetLocalDimmingAMD(device, swapChain, localDimmingEnable); +} +template +VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressEXT(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) { + Timer timer("vkGetBufferDeviceAddressEXT"); + VkDeviceAddress result = device_dispatch_table(device)->GetBufferDeviceAddressEXT(device, pInfo); + return result; +} +#if defined(VK_USE_PLATFORM_WIN32_KHR) +template +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain) { + Timer timer("vkAcquireFullScreenExclusiveModeEXT"); + VkResult result = device_dispatch_table(device)->AcquireFullScreenExclusiveModeEXT(device, swapchain); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkReleaseFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain) { + Timer timer("vkReleaseFullScreenExclusiveModeEXT"); + VkResult result = device_dispatch_table(device)->ReleaseFullScreenExclusiveModeEXT(device, swapchain); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModes2EXT(VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes) { + Timer timer("vkGetDeviceGroupSurfacePresentModes2EXT"); + VkResult result = device_dispatch_table(device)->GetDeviceGroupSurfacePresentModes2EXT(device, pSurfaceInfo, pModes); + return result; +} +#endif // VK_USE_PLATFORM_WIN32_KHR +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) { + Timer timer("vkCmdSetLineStippleEXT"); + device_dispatch_table(commandBuffer)->CmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern); +} +template +VKAPI_ATTR void VKAPI_CALL vkResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) { + Timer timer("vkResetQueryPoolEXT"); + device_dispatch_table(device)->ResetQueryPoolEXT(device, queryPool, firstQuery, queryCount); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) { + Timer timer("vkCmdSetCullModeEXT"); + device_dispatch_table(commandBuffer)->CmdSetCullModeEXT(commandBuffer, cullMode); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace) { + Timer timer("vkCmdSetFrontFaceEXT"); + device_dispatch_table(commandBuffer)->CmdSetFrontFaceEXT(commandBuffer, frontFace); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) { + Timer timer("vkCmdSetPrimitiveTopologyEXT"); + device_dispatch_table(commandBuffer)->CmdSetPrimitiveTopologyEXT(commandBuffer, primitiveTopology); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) { + Timer timer("vkCmdSetViewportWithCountEXT"); + device_dispatch_table(commandBuffer)->CmdSetViewportWithCountEXT(commandBuffer, viewportCount, pViewports); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) { + Timer timer("vkCmdSetScissorWithCountEXT"); + device_dispatch_table(commandBuffer)->CmdSetScissorWithCountEXT(commandBuffer, scissorCount, pScissors); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) { + Timer timer("vkCmdBindVertexBuffers2EXT"); + device_dispatch_table(commandBuffer)->CmdBindVertexBuffers2EXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) { + Timer timer("vkCmdSetDepthTestEnableEXT"); + device_dispatch_table(commandBuffer)->CmdSetDepthTestEnableEXT(commandBuffer, depthTestEnable); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) { + Timer timer("vkCmdSetDepthWriteEnableEXT"); + device_dispatch_table(commandBuffer)->CmdSetDepthWriteEnableEXT(commandBuffer, depthWriteEnable); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) { + Timer timer("vkCmdSetDepthCompareOpEXT"); + device_dispatch_table(commandBuffer)->CmdSetDepthCompareOpEXT(commandBuffer, depthCompareOp); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) { + Timer timer("vkCmdSetDepthBoundsTestEnableEXT"); + device_dispatch_table(commandBuffer)->CmdSetDepthBoundsTestEnableEXT(commandBuffer, depthBoundsTestEnable); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) { + Timer timer("vkCmdSetStencilTestEnableEXT"); + device_dispatch_table(commandBuffer)->CmdSetStencilTestEnableEXT(commandBuffer, stencilTestEnable); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilOpEXT(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) { + Timer timer("vkCmdSetStencilOpEXT"); + device_dispatch_table(commandBuffer)->CmdSetStencilOpEXT(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToImageEXT(VkDevice device, const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo) { + Timer timer("vkCopyMemoryToImageEXT"); + VkResult result = device_dispatch_table(device)->CopyMemoryToImageEXT(device, pCopyMemoryToImageInfo); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCopyImageToMemoryEXT(VkDevice device, const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo) { + Timer timer("vkCopyImageToMemoryEXT"); + VkResult result = device_dispatch_table(device)->CopyImageToMemoryEXT(device, pCopyImageToMemoryInfo); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCopyImageToImageEXT(VkDevice device, const VkCopyImageToImageInfo* pCopyImageToImageInfo) { + Timer timer("vkCopyImageToImageEXT"); + VkResult result = device_dispatch_table(device)->CopyImageToImageEXT(device, pCopyImageToImageInfo); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkTransitionImageLayoutEXT(VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfo* pTransitions) { + Timer timer("vkTransitionImageLayoutEXT"); + VkResult result = device_dispatch_table(device)->TransitionImageLayoutEXT(device, transitionCount, pTransitions); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout2EXT(VkDevice device, VkImage image, const VkImageSubresource2* pSubresource, VkSubresourceLayout2* pLayout) { + Timer timer("vkGetImageSubresourceLayout2EXT"); + device_dispatch_table(device)->GetImageSubresourceLayout2EXT(device, image, pSubresource, pLayout); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkReleaseSwapchainImagesEXT(VkDevice device, const VkReleaseSwapchainImagesInfoKHR* pReleaseInfo) { + Timer timer("vkReleaseSwapchainImagesEXT"); + VkResult result = device_dispatch_table(device)->ReleaseSwapchainImagesEXT(device, pReleaseInfo); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkGetGeneratedCommandsMemoryRequirementsNV(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + Timer timer("vkGetGeneratedCommandsMemoryRequirementsNV"); + device_dispatch_table(device)->GetGeneratedCommandsMemoryRequirementsNV(device, pInfo, pMemoryRequirements); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) { + Timer timer("vkCmdPreprocessGeneratedCommandsNV"); + device_dispatch_table(commandBuffer)->CmdPreprocessGeneratedCommandsNV(commandBuffer, pGeneratedCommandsInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) { + Timer timer("vkCmdExecuteGeneratedCommandsNV"); + device_dispatch_table(commandBuffer)->CmdExecuteGeneratedCommandsNV(commandBuffer, isPreprocessed, pGeneratedCommandsInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex) { + Timer timer("vkCmdBindPipelineShaderGroupNV"); + device_dispatch_table(commandBuffer)->CmdBindPipelineShaderGroupNV(commandBuffer, pipelineBindPoint, pipeline, groupIndex); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutNV(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNV* pIndirectCommandsLayout) { + Timer timer("vkCreateIndirectCommandsLayoutNV"); + VkResult result = device_dispatch_table(device)->CreateIndirectCommandsLayoutNV(device, pCreateInfo, pAllocator, pIndirectCommandsLayout); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutNV(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyIndirectCommandsLayoutNV"); + device_dispatch_table(device)->DestroyIndirectCommandsLayoutNV(device, indirectCommandsLayout, pAllocator); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias2EXT(VkCommandBuffer commandBuffer, const VkDepthBiasInfoEXT* pDepthBiasInfo) { + Timer timer("vkCmdSetDepthBias2EXT"); + device_dispatch_table(commandBuffer)->CmdSetDepthBias2EXT(commandBuffer, pDepthBiasInfo); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreatePrivateDataSlotEXT(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) { + Timer timer("vkCreatePrivateDataSlotEXT"); + VkResult result = device_dispatch_table(device)->CreatePrivateDataSlotEXT(device, pCreateInfo, pAllocator, pPrivateDataSlot); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyPrivateDataSlotEXT"); + device_dispatch_table(device)->DestroyPrivateDataSlotEXT(device, privateDataSlot, pAllocator); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) { + Timer timer("vkSetPrivateDataEXT"); + VkResult result = device_dispatch_table(device)->SetPrivateDataEXT(device, objectType, objectHandle, privateDataSlot, data); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkGetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData) { + Timer timer("vkGetPrivateDataEXT"); + device_dispatch_table(device)->GetPrivateDataEXT(device, objectType, objectHandle, privateDataSlot, pData); +} +#if defined(VK_ENABLE_BETA_EXTENSIONS) +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateCudaModuleNV(VkDevice device, const VkCudaModuleCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCudaModuleNV* pModule) { + Timer timer("vkCreateCudaModuleNV"); + VkResult result = device_dispatch_table(device)->CreateCudaModuleNV(device, pCreateInfo, pAllocator, pModule); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetCudaModuleCacheNV(VkDevice device, VkCudaModuleNV module, size_t* pCacheSize, void* pCacheData) { + Timer timer("vkGetCudaModuleCacheNV"); + VkResult result = device_dispatch_table(device)->GetCudaModuleCacheNV(device, module, pCacheSize, pCacheData); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateCudaFunctionNV(VkDevice device, const VkCudaFunctionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCudaFunctionNV* pFunction) { + Timer timer("vkCreateCudaFunctionNV"); + VkResult result = device_dispatch_table(device)->CreateCudaFunctionNV(device, pCreateInfo, pAllocator, pFunction); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyCudaModuleNV(VkDevice device, VkCudaModuleNV module, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyCudaModuleNV"); + device_dispatch_table(device)->DestroyCudaModuleNV(device, module, pAllocator); +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyCudaFunctionNV(VkDevice device, VkCudaFunctionNV function, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyCudaFunctionNV"); + device_dispatch_table(device)->DestroyCudaFunctionNV(device, function, pAllocator); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdCudaLaunchKernelNV(VkCommandBuffer commandBuffer, const VkCudaLaunchInfoNV* pLaunchInfo) { + Timer timer("vkCmdCudaLaunchKernelNV"); + device_dispatch_table(commandBuffer)->CmdCudaLaunchKernelNV(commandBuffer, pLaunchInfo); +} +#endif // VK_ENABLE_BETA_EXTENSIONS +template +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchTileQCOM(VkCommandBuffer commandBuffer, const VkDispatchTileInfoQCOM* pDispatchTileInfo) { + Timer timer("vkCmdDispatchTileQCOM"); + device_dispatch_table(commandBuffer)->CmdDispatchTileQCOM(commandBuffer, pDispatchTileInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdBeginPerTileExecutionQCOM(VkCommandBuffer commandBuffer, const VkPerTileBeginInfoQCOM* pPerTileBeginInfo) { + Timer timer("vkCmdBeginPerTileExecutionQCOM"); + device_dispatch_table(commandBuffer)->CmdBeginPerTileExecutionQCOM(commandBuffer, pPerTileBeginInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdEndPerTileExecutionQCOM(VkCommandBuffer commandBuffer, const VkPerTileEndInfoQCOM* pPerTileEndInfo) { + Timer timer("vkCmdEndPerTileExecutionQCOM"); + device_dispatch_table(commandBuffer)->CmdEndPerTileExecutionQCOM(commandBuffer, pPerTileEndInfo); +} +#if defined(VK_USE_PLATFORM_METAL_EXT) +template +VKAPI_ATTR void VKAPI_CALL vkExportMetalObjectsEXT(VkDevice device, VkExportMetalObjectsInfoEXT* pMetalObjectsInfo) { + Timer timer("vkExportMetalObjectsEXT"); + device_dispatch_table(device)->ExportMetalObjectsEXT(device, pMetalObjectsInfo); +} +#endif // VK_USE_PLATFORM_METAL_EXT +template +VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSizeEXT(VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize* pLayoutSizeInBytes) { + Timer timer("vkGetDescriptorSetLayoutSizeEXT"); + device_dispatch_table(device)->GetDescriptorSetLayoutSizeEXT(device, layout, pLayoutSizeInBytes); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutBindingOffsetEXT(VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize* pOffset) { + Timer timer("vkGetDescriptorSetLayoutBindingOffsetEXT"); + device_dispatch_table(device)->GetDescriptorSetLayoutBindingOffsetEXT(device, layout, binding, pOffset); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetDescriptorEXT(VkDevice device, const VkDescriptorGetInfoEXT* pDescriptorInfo, size_t dataSize, void* pDescriptor) { + Timer timer("vkGetDescriptorEXT"); + device_dispatch_table(device)->GetDescriptorEXT(device, pDescriptorInfo, dataSize, pDescriptor); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorBuffersEXT(VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT* pBindingInfos) { + Timer timer("vkCmdBindDescriptorBuffersEXT"); + device_dispatch_table(commandBuffer)->CmdBindDescriptorBuffersEXT(commandBuffer, bufferCount, pBindingInfos); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetDescriptorBufferOffsetsEXT(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t* pBufferIndices, const VkDeviceSize* pOffsets) { + Timer timer("vkCmdSetDescriptorBufferOffsetsEXT"); + device_dispatch_table(commandBuffer)->CmdSetDescriptorBufferOffsetsEXT(commandBuffer, pipelineBindPoint, layout, firstSet, setCount, pBufferIndices, pOffsets); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorBufferEmbeddedSamplersEXT(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set) { + Timer timer("vkCmdBindDescriptorBufferEmbeddedSamplersEXT"); + device_dispatch_table(commandBuffer)->CmdBindDescriptorBufferEmbeddedSamplersEXT(commandBuffer, pipelineBindPoint, layout, set); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetBufferOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT* pInfo, void* pData) { + Timer timer("vkGetBufferOpaqueCaptureDescriptorDataEXT"); + VkResult result = device_dispatch_table(device)->GetBufferOpaqueCaptureDescriptorDataEXT(device, pInfo, pData); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetImageOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkImageCaptureDescriptorDataInfoEXT* pInfo, void* pData) { + Timer timer("vkGetImageOpaqueCaptureDescriptorDataEXT"); + VkResult result = device_dispatch_table(device)->GetImageOpaqueCaptureDescriptorDataEXT(device, pInfo, pData); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetImageViewOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, void* pData) { + Timer timer("vkGetImageViewOpaqueCaptureDescriptorDataEXT"); + VkResult result = device_dispatch_table(device)->GetImageViewOpaqueCaptureDescriptorDataEXT(device, pInfo, pData); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetSamplerOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT* pInfo, void* pData) { + Timer timer("vkGetSamplerOpaqueCaptureDescriptorDataEXT"); + VkResult result = device_dispatch_table(device)->GetSamplerOpaqueCaptureDescriptorDataEXT(device, pInfo, pData); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, void* pData) { + Timer timer("vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT"); + VkResult result = device_dispatch_table(device)->GetAccelerationStructureOpaqueCaptureDescriptorDataEXT(device, pInfo, pData); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateEnumNV(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) { + Timer timer("vkCmdSetFragmentShadingRateEnumNV"); + device_dispatch_table(commandBuffer)->CmdSetFragmentShadingRateEnumNV(commandBuffer, shadingRate, combinerOps); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceFaultInfoEXT(VkDevice device, VkDeviceFaultCountsEXT* pFaultCounts, VkDeviceFaultInfoEXT* pFaultInfo) { + Timer timer("vkGetDeviceFaultInfoEXT"); + VkResult result = device_dispatch_table(device)->GetDeviceFaultInfoEXT(device, pFaultCounts, pFaultInfo); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetVertexInputEXT(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions) { + Timer timer("vkCmdSetVertexInputEXT"); + device_dispatch_table(commandBuffer)->CmdSetVertexInputEXT(commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions); +} +#if defined(VK_USE_PLATFORM_FUCHSIA) +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryZirconHandleFUCHSIA(VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle) { + Timer timer("vkGetMemoryZirconHandleFUCHSIA"); + VkResult result = device_dispatch_table(device)->GetMemoryZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryZirconHandlePropertiesFUCHSIA(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties) { + Timer timer("vkGetMemoryZirconHandlePropertiesFUCHSIA"); + VkResult result = device_dispatch_table(device)->GetMemoryZirconHandlePropertiesFUCHSIA(device, handleType, zirconHandle, pMemoryZirconHandleProperties); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreZirconHandleFUCHSIA(VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo) { + Timer timer("vkImportSemaphoreZirconHandleFUCHSIA"); + VkResult result = device_dispatch_table(device)->ImportSemaphoreZirconHandleFUCHSIA(device, pImportSemaphoreZirconHandleInfo); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreZirconHandleFUCHSIA(VkDevice device, const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle) { + Timer timer("vkGetSemaphoreZirconHandleFUCHSIA"); + VkResult result = device_dispatch_table(device)->GetSemaphoreZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferCollectionFUCHSIA(VkDevice device, const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferCollectionFUCHSIA* pCollection) { + Timer timer("vkCreateBufferCollectionFUCHSIA"); + VkResult result = device_dispatch_table(device)->CreateBufferCollectionFUCHSIA(device, pCreateInfo, pAllocator, pCollection); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkSetBufferCollectionImageConstraintsFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo) { + Timer timer("vkSetBufferCollectionImageConstraintsFUCHSIA"); + VkResult result = device_dispatch_table(device)->SetBufferCollectionImageConstraintsFUCHSIA(device, collection, pImageConstraintsInfo); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkSetBufferCollectionBufferConstraintsFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo) { + Timer timer("vkSetBufferCollectionBufferConstraintsFUCHSIA"); + VkResult result = device_dispatch_table(device)->SetBufferCollectionBufferConstraintsFUCHSIA(device, collection, pBufferConstraintsInfo); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyBufferCollectionFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyBufferCollectionFUCHSIA"); + device_dispatch_table(device)->DestroyBufferCollectionFUCHSIA(device, collection, pAllocator); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetBufferCollectionPropertiesFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, VkBufferCollectionPropertiesFUCHSIA* pProperties) { + Timer timer("vkGetBufferCollectionPropertiesFUCHSIA"); + VkResult result = device_dispatch_table(device)->GetBufferCollectionPropertiesFUCHSIA(device, collection, pProperties); + return result; +} +#endif // VK_USE_PLATFORM_FUCHSIA +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(VkDevice device, VkRenderPass renderpass, VkExtent2D* pMaxWorkgroupSize) { + Timer timer("vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI"); + VkResult result = device_dispatch_table(device)->GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(device, renderpass, pMaxWorkgroupSize); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSubpassShadingHUAWEI(VkCommandBuffer commandBuffer) { + Timer timer("vkCmdSubpassShadingHUAWEI"); + device_dispatch_table(commandBuffer)->CmdSubpassShadingHUAWEI(commandBuffer); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdBindInvocationMaskHUAWEI(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) { + Timer timer("vkCmdBindInvocationMaskHUAWEI"); + device_dispatch_table(commandBuffer)->CmdBindInvocationMaskHUAWEI(commandBuffer, imageView, imageLayout); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryRemoteAddressNV(VkDevice device, const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, VkRemoteAddressNV* pAddress) { + Timer timer("vkGetMemoryRemoteAddressNV"); + VkResult result = device_dispatch_table(device)->GetMemoryRemoteAddressNV(device, pMemoryGetRemoteAddressInfo, pAddress); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelinePropertiesEXT(VkDevice device, const VkPipelineInfoEXT* pPipelineInfo, VkBaseOutStructure* pPipelineProperties) { + Timer timer("vkGetPipelinePropertiesEXT"); + VkResult result = device_dispatch_table(device)->GetPipelinePropertiesEXT(device, pPipelineInfo, pPipelineProperties); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints) { + Timer timer("vkCmdSetPatchControlPointsEXT"); + device_dispatch_table(commandBuffer)->CmdSetPatchControlPointsEXT(commandBuffer, patchControlPoints); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) { + Timer timer("vkCmdSetRasterizerDiscardEnableEXT"); + device_dispatch_table(commandBuffer)->CmdSetRasterizerDiscardEnableEXT(commandBuffer, rasterizerDiscardEnable); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) { + Timer timer("vkCmdSetDepthBiasEnableEXT"); + device_dispatch_table(commandBuffer)->CmdSetDepthBiasEnableEXT(commandBuffer, depthBiasEnable); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp) { + Timer timer("vkCmdSetLogicOpEXT"); + device_dispatch_table(commandBuffer)->CmdSetLogicOpEXT(commandBuffer, logicOp); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) { + Timer timer("vkCmdSetPrimitiveRestartEnableEXT"); + device_dispatch_table(commandBuffer)->CmdSetPrimitiveRestartEnableEXT(commandBuffer, primitiveRestartEnable); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables) { + Timer timer("vkCmdSetColorWriteEnableEXT"); + device_dispatch_table(commandBuffer)->CmdSetColorWriteEnableEXT(commandBuffer, attachmentCount, pColorWriteEnables); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdDrawMultiEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride) { + Timer timer("vkCmdDrawMultiEXT"); + device_dispatch_table(commandBuffer)->CmdDrawMultiEXT(commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdDrawMultiIndexedEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset) { + Timer timer("vkCmdDrawMultiIndexedEXT"); + device_dispatch_table(commandBuffer)->CmdDrawMultiIndexedEXT(commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateMicromapEXT(VkDevice device, const VkMicromapCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkMicromapEXT* pMicromap) { + Timer timer("vkCreateMicromapEXT"); + VkResult result = device_dispatch_table(device)->CreateMicromapEXT(device, pCreateInfo, pAllocator, pMicromap); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyMicromapEXT(VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyMicromapEXT"); + device_dispatch_table(device)->DestroyMicromapEXT(device, micromap, pAllocator); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdBuildMicromapsEXT(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos) { + Timer timer("vkCmdBuildMicromapsEXT"); + device_dispatch_table(commandBuffer)->CmdBuildMicromapsEXT(commandBuffer, infoCount, pInfos); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkBuildMicromapsEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos) { + Timer timer("vkBuildMicromapsEXT"); + VkResult result = device_dispatch_table(device)->BuildMicromapsEXT(device, deferredOperation, infoCount, pInfos); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCopyMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT* pInfo) { + Timer timer("vkCopyMicromapEXT"); + VkResult result = device_dispatch_table(device)->CopyMicromapEXT(device, deferredOperation, pInfo); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCopyMicromapToMemoryEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT* pInfo) { + Timer timer("vkCopyMicromapToMemoryEXT"); + VkResult result = device_dispatch_table(device)->CopyMicromapToMemoryEXT(device, deferredOperation, pInfo); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT* pInfo) { + Timer timer("vkCopyMemoryToMicromapEXT"); + VkResult result = device_dispatch_table(device)->CopyMemoryToMicromapEXT(device, deferredOperation, pInfo); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, size_t dataSize, void* pData, size_t stride) { + Timer timer("vkWriteMicromapsPropertiesEXT"); + VkResult result = device_dispatch_table(device)->WriteMicromapsPropertiesEXT(device, micromapCount, pMicromaps, queryType, dataSize, pData, stride); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdCopyMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT* pInfo) { + Timer timer("vkCmdCopyMicromapEXT"); + device_dispatch_table(commandBuffer)->CmdCopyMicromapEXT(commandBuffer, pInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdCopyMicromapToMemoryEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT* pInfo) { + Timer timer("vkCmdCopyMicromapToMemoryEXT"); + device_dispatch_table(commandBuffer)->CmdCopyMicromapToMemoryEXT(commandBuffer, pInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT* pInfo) { + Timer timer("vkCmdCopyMemoryToMicromapEXT"); + device_dispatch_table(commandBuffer)->CmdCopyMemoryToMicromapEXT(commandBuffer, pInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdWriteMicromapsPropertiesEXT(VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) { + Timer timer("vkCmdWriteMicromapsPropertiesEXT"); + device_dispatch_table(commandBuffer)->CmdWriteMicromapsPropertiesEXT(commandBuffer, micromapCount, pMicromaps, queryType, queryPool, firstQuery); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetDeviceMicromapCompatibilityEXT(VkDevice device, const VkMicromapVersionInfoEXT* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility) { + Timer timer("vkGetDeviceMicromapCompatibilityEXT"); + device_dispatch_table(device)->GetDeviceMicromapCompatibilityEXT(device, pVersionInfo, pCompatibility); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetMicromapBuildSizesEXT(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT* pBuildInfo, VkMicromapBuildSizesInfoEXT* pSizeInfo) { + Timer timer("vkGetMicromapBuildSizesEXT"); + device_dispatch_table(device)->GetMicromapBuildSizesEXT(device, buildType, pBuildInfo, pSizeInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdDrawClusterHUAWEI(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) { + Timer timer("vkCmdDrawClusterHUAWEI"); + device_dispatch_table(commandBuffer)->CmdDrawClusterHUAWEI(commandBuffer, groupCountX, groupCountY, groupCountZ); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdDrawClusterIndirectHUAWEI(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) { + Timer timer("vkCmdDrawClusterIndirectHUAWEI"); + device_dispatch_table(commandBuffer)->CmdDrawClusterIndirectHUAWEI(commandBuffer, buffer, offset); +} +template +VKAPI_ATTR void VKAPI_CALL vkSetDeviceMemoryPriorityEXT(VkDevice device, VkDeviceMemory memory, float priority) { + Timer timer("vkSetDeviceMemoryPriorityEXT"); + device_dispatch_table(device)->SetDeviceMemoryPriorityEXT(device, memory, priority); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutHostMappingInfoVALVE(VkDevice device, const VkDescriptorSetBindingReferenceVALVE* pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping) { + Timer timer("vkGetDescriptorSetLayoutHostMappingInfoVALVE"); + device_dispatch_table(device)->GetDescriptorSetLayoutHostMappingInfoVALVE(device, pBindingReference, pHostMapping); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetHostMappingVALVE(VkDevice device, VkDescriptorSet descriptorSet, void** ppData) { + Timer timer("vkGetDescriptorSetHostMappingVALVE"); + device_dispatch_table(device)->GetDescriptorSetHostMappingVALVE(device, descriptorSet, ppData); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride) { + Timer timer("vkCmdCopyMemoryIndirectNV"); + device_dispatch_table(commandBuffer)->CmdCopyMemoryIndirectNV(commandBuffer, copyBufferAddress, copyCount, stride); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToImageIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VkImage dstImage, VkImageLayout dstImageLayout, const VkImageSubresourceLayers* pImageSubresources) { + Timer timer("vkCmdCopyMemoryToImageIndirectNV"); + device_dispatch_table(commandBuffer)->CmdCopyMemoryToImageIndirectNV(commandBuffer, copyBufferAddress, copyCount, stride, dstImage, dstImageLayout, pImageSubresources); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdDecompressMemoryNV(VkCommandBuffer commandBuffer, uint32_t decompressRegionCount, const VkDecompressMemoryRegionNV* pDecompressMemoryRegions) { + Timer timer("vkCmdDecompressMemoryNV"); + device_dispatch_table(commandBuffer)->CmdDecompressMemoryNV(commandBuffer, decompressRegionCount, pDecompressMemoryRegions); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdDecompressMemoryIndirectCountNV(VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t stride) { + Timer timer("vkCmdDecompressMemoryIndirectCountNV"); + device_dispatch_table(commandBuffer)->CmdDecompressMemoryIndirectCountNV(commandBuffer, indirectCommandsAddress, indirectCommandsCountAddress, stride); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetPipelineIndirectMemoryRequirementsNV(VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo, VkMemoryRequirements2* pMemoryRequirements) { + Timer timer("vkGetPipelineIndirectMemoryRequirementsNV"); + device_dispatch_table(device)->GetPipelineIndirectMemoryRequirementsNV(device, pCreateInfo, pMemoryRequirements); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdUpdatePipelineIndirectBufferNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) { + Timer timer("vkCmdUpdatePipelineIndirectBufferNV"); + device_dispatch_table(commandBuffer)->CmdUpdatePipelineIndirectBufferNV(commandBuffer, pipelineBindPoint, pipeline); +} +template +VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetPipelineIndirectDeviceAddressNV(VkDevice device, const VkPipelineIndirectDeviceAddressInfoNV* pInfo) { + Timer timer("vkGetPipelineIndirectDeviceAddressNV"); + VkDeviceAddress result = device_dispatch_table(device)->GetPipelineIndirectDeviceAddressNV(device, pInfo); + return result; +} +#if defined(VK_USE_PLATFORM_OHOS) +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetNativeBufferPropertiesOHOS(VkDevice device, const struct OH_NativeBuffer* buffer, VkNativeBufferPropertiesOHOS* pProperties) { + Timer timer("vkGetNativeBufferPropertiesOHOS"); + VkResult result = device_dispatch_table(device)->GetNativeBufferPropertiesOHOS(device, buffer, pProperties); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryNativeBufferOHOS(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, struct OH_NativeBuffer** pBuffer) { + Timer timer("vkGetMemoryNativeBufferOHOS"); + VkResult result = device_dispatch_table(device)->GetMemoryNativeBufferOHOS(device, pInfo, pBuffer); + return result; +} +#endif // VK_USE_PLATFORM_OHOS +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClampEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable) { + Timer timer("vkCmdSetDepthClampEnableEXT"); + device_dispatch_table(commandBuffer)->CmdSetDepthClampEnableEXT(commandBuffer, depthClampEnable); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetPolygonModeEXT(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode) { + Timer timer("vkCmdSetPolygonModeEXT"); + device_dispatch_table(commandBuffer)->CmdSetPolygonModeEXT(commandBuffer, polygonMode); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizationSamplesEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples) { + Timer timer("vkCmdSetRasterizationSamplesEXT"); + device_dispatch_table(commandBuffer)->CmdSetRasterizationSamplesEXT(commandBuffer, rasterizationSamples); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleMaskEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask* pSampleMask) { + Timer timer("vkCmdSetSampleMaskEXT"); + device_dispatch_table(commandBuffer)->CmdSetSampleMaskEXT(commandBuffer, samples, pSampleMask); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetAlphaToCoverageEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable) { + Timer timer("vkCmdSetAlphaToCoverageEnableEXT"); + device_dispatch_table(commandBuffer)->CmdSetAlphaToCoverageEnableEXT(commandBuffer, alphaToCoverageEnable); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetAlphaToOneEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable) { + Timer timer("vkCmdSetAlphaToOneEnableEXT"); + device_dispatch_table(commandBuffer)->CmdSetAlphaToOneEnableEXT(commandBuffer, alphaToOneEnable); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetLogicOpEnableEXT(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable) { + Timer timer("vkCmdSetLogicOpEnableEXT"); + device_dispatch_table(commandBuffer)->CmdSetLogicOpEnableEXT(commandBuffer, logicOpEnable); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetColorBlendEnableEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32* pColorBlendEnables) { + Timer timer("vkCmdSetColorBlendEnableEXT"); + device_dispatch_table(commandBuffer)->CmdSetColorBlendEnableEXT(commandBuffer, firstAttachment, attachmentCount, pColorBlendEnables); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetColorBlendEquationEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT* pColorBlendEquations) { + Timer timer("vkCmdSetColorBlendEquationEXT"); + device_dispatch_table(commandBuffer)->CmdSetColorBlendEquationEXT(commandBuffer, firstAttachment, attachmentCount, pColorBlendEquations); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetColorWriteMaskEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags* pColorWriteMasks) { + Timer timer("vkCmdSetColorWriteMaskEXT"); + device_dispatch_table(commandBuffer)->CmdSetColorWriteMaskEXT(commandBuffer, firstAttachment, attachmentCount, pColorWriteMasks); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetTessellationDomainOriginEXT(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin) { + Timer timer("vkCmdSetTessellationDomainOriginEXT"); + device_dispatch_table(commandBuffer)->CmdSetTessellationDomainOriginEXT(commandBuffer, domainOrigin); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizationStreamEXT(VkCommandBuffer commandBuffer, uint32_t rasterizationStream) { + Timer timer("vkCmdSetRasterizationStreamEXT"); + device_dispatch_table(commandBuffer)->CmdSetRasterizationStreamEXT(commandBuffer, rasterizationStream); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetConservativeRasterizationModeEXT(VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode) { + Timer timer("vkCmdSetConservativeRasterizationModeEXT"); + device_dispatch_table(commandBuffer)->CmdSetConservativeRasterizationModeEXT(commandBuffer, conservativeRasterizationMode); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetExtraPrimitiveOverestimationSizeEXT(VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize) { + Timer timer("vkCmdSetExtraPrimitiveOverestimationSizeEXT"); + device_dispatch_table(commandBuffer)->CmdSetExtraPrimitiveOverestimationSizeEXT(commandBuffer, extraPrimitiveOverestimationSize); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClipEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable) { + Timer timer("vkCmdSetDepthClipEnableEXT"); + device_dispatch_table(commandBuffer)->CmdSetDepthClipEnableEXT(commandBuffer, depthClipEnable); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEnableEXT(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable) { + Timer timer("vkCmdSetSampleLocationsEnableEXT"); + device_dispatch_table(commandBuffer)->CmdSetSampleLocationsEnableEXT(commandBuffer, sampleLocationsEnable); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetColorBlendAdvancedEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT* pColorBlendAdvanced) { + Timer timer("vkCmdSetColorBlendAdvancedEXT"); + device_dispatch_table(commandBuffer)->CmdSetColorBlendAdvancedEXT(commandBuffer, firstAttachment, attachmentCount, pColorBlendAdvanced); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetProvokingVertexModeEXT(VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode) { + Timer timer("vkCmdSetProvokingVertexModeEXT"); + device_dispatch_table(commandBuffer)->CmdSetProvokingVertexModeEXT(commandBuffer, provokingVertexMode); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetLineRasterizationModeEXT(VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode) { + Timer timer("vkCmdSetLineRasterizationModeEXT"); + device_dispatch_table(commandBuffer)->CmdSetLineRasterizationModeEXT(commandBuffer, lineRasterizationMode); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable) { + Timer timer("vkCmdSetLineStippleEnableEXT"); + device_dispatch_table(commandBuffer)->CmdSetLineStippleEnableEXT(commandBuffer, stippledLineEnable); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClipNegativeOneToOneEXT(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne) { + Timer timer("vkCmdSetDepthClipNegativeOneToOneEXT"); + device_dispatch_table(commandBuffer)->CmdSetDepthClipNegativeOneToOneEXT(commandBuffer, negativeOneToOne); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingEnableNV(VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable) { + Timer timer("vkCmdSetViewportWScalingEnableNV"); + device_dispatch_table(commandBuffer)->CmdSetViewportWScalingEnableNV(commandBuffer, viewportWScalingEnable); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportSwizzleNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV* pViewportSwizzles) { + Timer timer("vkCmdSetViewportSwizzleNV"); + device_dispatch_table(commandBuffer)->CmdSetViewportSwizzleNV(commandBuffer, firstViewport, viewportCount, pViewportSwizzles); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageToColorEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable) { + Timer timer("vkCmdSetCoverageToColorEnableNV"); + device_dispatch_table(commandBuffer)->CmdSetCoverageToColorEnableNV(commandBuffer, coverageToColorEnable); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageToColorLocationNV(VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation) { + Timer timer("vkCmdSetCoverageToColorLocationNV"); + device_dispatch_table(commandBuffer)->CmdSetCoverageToColorLocationNV(commandBuffer, coverageToColorLocation); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageModulationModeNV(VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode) { + Timer timer("vkCmdSetCoverageModulationModeNV"); + device_dispatch_table(commandBuffer)->CmdSetCoverageModulationModeNV(commandBuffer, coverageModulationMode); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageModulationTableEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable) { + Timer timer("vkCmdSetCoverageModulationTableEnableNV"); + device_dispatch_table(commandBuffer)->CmdSetCoverageModulationTableEnableNV(commandBuffer, coverageModulationTableEnable); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageModulationTableNV(VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float* pCoverageModulationTable) { + Timer timer("vkCmdSetCoverageModulationTableNV"); + device_dispatch_table(commandBuffer)->CmdSetCoverageModulationTableNV(commandBuffer, coverageModulationTableCount, pCoverageModulationTable); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetShadingRateImageEnableNV(VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable) { + Timer timer("vkCmdSetShadingRateImageEnableNV"); + device_dispatch_table(commandBuffer)->CmdSetShadingRateImageEnableNV(commandBuffer, shadingRateImageEnable); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetRepresentativeFragmentTestEnableNV(VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable) { + Timer timer("vkCmdSetRepresentativeFragmentTestEnableNV"); + device_dispatch_table(commandBuffer)->CmdSetRepresentativeFragmentTestEnableNV(commandBuffer, representativeFragmentTestEnable); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageReductionModeNV(VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode) { + Timer timer("vkCmdSetCoverageReductionModeNV"); + device_dispatch_table(commandBuffer)->CmdSetCoverageReductionModeNV(commandBuffer, coverageReductionMode); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateTensorARM(VkDevice device, const VkTensorCreateInfoARM* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkTensorARM* pTensor) { + Timer timer("vkCreateTensorARM"); + VkResult result = device_dispatch_table(device)->CreateTensorARM(device, pCreateInfo, pAllocator, pTensor); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyTensorARM(VkDevice device, VkTensorARM tensor, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyTensorARM"); + device_dispatch_table(device)->DestroyTensorARM(device, tensor, pAllocator); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateTensorViewARM(VkDevice device, const VkTensorViewCreateInfoARM* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkTensorViewARM* pView) { + Timer timer("vkCreateTensorViewARM"); + VkResult result = device_dispatch_table(device)->CreateTensorViewARM(device, pCreateInfo, pAllocator, pView); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyTensorViewARM(VkDevice device, VkTensorViewARM tensorView, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyTensorViewARM"); + device_dispatch_table(device)->DestroyTensorViewARM(device, tensorView, pAllocator); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetTensorMemoryRequirementsARM(VkDevice device, const VkTensorMemoryRequirementsInfoARM* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + Timer timer("vkGetTensorMemoryRequirementsARM"); + device_dispatch_table(device)->GetTensorMemoryRequirementsARM(device, pInfo, pMemoryRequirements); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkBindTensorMemoryARM(VkDevice device, uint32_t bindInfoCount, const VkBindTensorMemoryInfoARM* pBindInfos) { + Timer timer("vkBindTensorMemoryARM"); + VkResult result = device_dispatch_table(device)->BindTensorMemoryARM(device, bindInfoCount, pBindInfos); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkGetDeviceTensorMemoryRequirementsARM(VkDevice device, const VkDeviceTensorMemoryRequirementsARM* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + Timer timer("vkGetDeviceTensorMemoryRequirementsARM"); + device_dispatch_table(device)->GetDeviceTensorMemoryRequirementsARM(device, pInfo, pMemoryRequirements); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdCopyTensorARM(VkCommandBuffer commandBuffer, const VkCopyTensorInfoARM* pCopyTensorInfo) { + Timer timer("vkCmdCopyTensorARM"); + device_dispatch_table(commandBuffer)->CmdCopyTensorARM(commandBuffer, pCopyTensorInfo); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetTensorOpaqueCaptureDescriptorDataARM(VkDevice device, const VkTensorCaptureDescriptorDataInfoARM* pInfo, void* pData) { + Timer timer("vkGetTensorOpaqueCaptureDescriptorDataARM"); + VkResult result = device_dispatch_table(device)->GetTensorOpaqueCaptureDescriptorDataARM(device, pInfo, pData); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetTensorViewOpaqueCaptureDescriptorDataARM(VkDevice device, const VkTensorViewCaptureDescriptorDataInfoARM* pInfo, void* pData) { + Timer timer("vkGetTensorViewOpaqueCaptureDescriptorDataARM"); + VkResult result = device_dispatch_table(device)->GetTensorViewOpaqueCaptureDescriptorDataARM(device, pInfo, pData); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkGetShaderModuleIdentifierEXT(VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT* pIdentifier) { + Timer timer("vkGetShaderModuleIdentifierEXT"); + device_dispatch_table(device)->GetShaderModuleIdentifierEXT(device, shaderModule, pIdentifier); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetShaderModuleCreateInfoIdentifierEXT(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModuleIdentifierEXT* pIdentifier) { + Timer timer("vkGetShaderModuleCreateInfoIdentifierEXT"); + device_dispatch_table(device)->GetShaderModuleCreateInfoIdentifierEXT(device, pCreateInfo, pIdentifier); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateOpticalFlowSessionNV(VkDevice device, const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkOpticalFlowSessionNV* pSession) { + Timer timer("vkCreateOpticalFlowSessionNV"); + VkResult result = device_dispatch_table(device)->CreateOpticalFlowSessionNV(device, pCreateInfo, pAllocator, pSession); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyOpticalFlowSessionNV(VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyOpticalFlowSessionNV"); + device_dispatch_table(device)->DestroyOpticalFlowSessionNV(device, session, pAllocator); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkBindOpticalFlowSessionImageNV(VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout) { + Timer timer("vkBindOpticalFlowSessionImageNV"); + VkResult result = device_dispatch_table(device)->BindOpticalFlowSessionImageNV(device, session, bindingPoint, view, layout); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdOpticalFlowExecuteNV(VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV* pExecuteInfo) { + Timer timer("vkCmdOpticalFlowExecuteNV"); + device_dispatch_table(commandBuffer)->CmdOpticalFlowExecuteNV(commandBuffer, session, pExecuteInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkAntiLagUpdateAMD(VkDevice device, const VkAntiLagDataAMD* pData) { + Timer timer("vkAntiLagUpdateAMD"); + device_dispatch_table(device)->AntiLagUpdateAMD(device, pData); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateShadersEXT(VkDevice device, uint32_t createInfoCount, const VkShaderCreateInfoEXT* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkShaderEXT* pShaders) { + Timer timer("vkCreateShadersEXT"); + VkResult result = device_dispatch_table(device)->CreateShadersEXT(device, createInfoCount, pCreateInfos, pAllocator, pShaders); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyShaderEXT(VkDevice device, VkShaderEXT shader, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyShaderEXT"); + device_dispatch_table(device)->DestroyShaderEXT(device, shader, pAllocator); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetShaderBinaryDataEXT(VkDevice device, VkShaderEXT shader, size_t* pDataSize, void* pData) { + Timer timer("vkGetShaderBinaryDataEXT"); + VkResult result = device_dispatch_table(device)->GetShaderBinaryDataEXT(device, shader, pDataSize, pData); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdBindShadersEXT(VkCommandBuffer commandBuffer, uint32_t stageCount, const VkShaderStageFlagBits* pStages, const VkShaderEXT* pShaders) { + Timer timer("vkCmdBindShadersEXT"); + device_dispatch_table(commandBuffer)->CmdBindShadersEXT(commandBuffer, stageCount, pStages, pShaders); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClampRangeEXT(VkCommandBuffer commandBuffer, VkDepthClampModeEXT depthClampMode, const VkDepthClampRangeEXT* pDepthClampRange) { + Timer timer("vkCmdSetDepthClampRangeEXT"); + device_dispatch_table(commandBuffer)->CmdSetDepthClampRangeEXT(commandBuffer, depthClampMode, pDepthClampRange); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetFramebufferTilePropertiesQCOM(VkDevice device, VkFramebuffer framebuffer, uint32_t* pPropertiesCount, VkTilePropertiesQCOM* pProperties) { + Timer timer("vkGetFramebufferTilePropertiesQCOM"); + VkResult result = device_dispatch_table(device)->GetFramebufferTilePropertiesQCOM(device, framebuffer, pPropertiesCount, pProperties); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties) { + Timer timer("vkGetDynamicRenderingTilePropertiesQCOM"); + VkResult result = device_dispatch_table(device)->GetDynamicRenderingTilePropertiesQCOM(device, pRenderingInfo, pProperties); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkConvertCooperativeVectorMatrixNV(VkDevice device, const VkConvertCooperativeVectorMatrixInfoNV* pInfo) { + Timer timer("vkConvertCooperativeVectorMatrixNV"); + VkResult result = device_dispatch_table(device)->ConvertCooperativeVectorMatrixNV(device, pInfo); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdConvertCooperativeVectorMatrixNV(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkConvertCooperativeVectorMatrixInfoNV* pInfos) { + Timer timer("vkCmdConvertCooperativeVectorMatrixNV"); + device_dispatch_table(commandBuffer)->CmdConvertCooperativeVectorMatrixNV(commandBuffer, infoCount, pInfos); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkSetLatencySleepModeNV(VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepModeInfoNV* pSleepModeInfo) { + Timer timer("vkSetLatencySleepModeNV"); + VkResult result = device_dispatch_table(device)->SetLatencySleepModeNV(device, swapchain, pSleepModeInfo); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkLatencySleepNV(VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepInfoNV* pSleepInfo) { + Timer timer("vkLatencySleepNV"); + VkResult result = device_dispatch_table(device)->LatencySleepNV(device, swapchain, pSleepInfo); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkSetLatencyMarkerNV(VkDevice device, VkSwapchainKHR swapchain, const VkSetLatencyMarkerInfoNV* pLatencyMarkerInfo) { + Timer timer("vkSetLatencyMarkerNV"); + device_dispatch_table(device)->SetLatencyMarkerNV(device, swapchain, pLatencyMarkerInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetLatencyTimingsNV(VkDevice device, VkSwapchainKHR swapchain, VkGetLatencyMarkerInfoNV* pLatencyMarkerInfo) { + Timer timer("vkGetLatencyTimingsNV"); + device_dispatch_table(device)->GetLatencyTimingsNV(device, swapchain, pLatencyMarkerInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkQueueNotifyOutOfBandNV(VkQueue queue, const VkOutOfBandQueueTypeInfoNV* pQueueTypeInfo) { + Timer timer("vkQueueNotifyOutOfBandNV"); + device_dispatch_table(queue)->QueueNotifyOutOfBandNV(queue, pQueueTypeInfo); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDataGraphPipelinesARM(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkDataGraphPipelineCreateInfoARM* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { + Timer timer("vkCreateDataGraphPipelinesARM"); + VkResult result = device_dispatch_table(device)->CreateDataGraphPipelinesARM(device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDataGraphPipelineSessionARM(VkDevice device, const VkDataGraphPipelineSessionCreateInfoARM* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDataGraphPipelineSessionARM* pSession) { + Timer timer("vkCreateDataGraphPipelineSessionARM"); + VkResult result = device_dispatch_table(device)->CreateDataGraphPipelineSessionARM(device, pCreateInfo, pAllocator, pSession); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetDataGraphPipelineSessionBindPointRequirementsARM(VkDevice device, const VkDataGraphPipelineSessionBindPointRequirementsInfoARM* pInfo, uint32_t* pBindPointRequirementCount, VkDataGraphPipelineSessionBindPointRequirementARM* pBindPointRequirements) { + Timer timer("vkGetDataGraphPipelineSessionBindPointRequirementsARM"); + VkResult result = device_dispatch_table(device)->GetDataGraphPipelineSessionBindPointRequirementsARM(device, pInfo, pBindPointRequirementCount, pBindPointRequirements); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkGetDataGraphPipelineSessionMemoryRequirementsARM(VkDevice device, const VkDataGraphPipelineSessionMemoryRequirementsInfoARM* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + Timer timer("vkGetDataGraphPipelineSessionMemoryRequirementsARM"); + device_dispatch_table(device)->GetDataGraphPipelineSessionMemoryRequirementsARM(device, pInfo, pMemoryRequirements); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkBindDataGraphPipelineSessionMemoryARM(VkDevice device, uint32_t bindInfoCount, const VkBindDataGraphPipelineSessionMemoryInfoARM* pBindInfos) { + Timer timer("vkBindDataGraphPipelineSessionMemoryARM"); + VkResult result = device_dispatch_table(device)->BindDataGraphPipelineSessionMemoryARM(device, bindInfoCount, pBindInfos); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyDataGraphPipelineSessionARM(VkDevice device, VkDataGraphPipelineSessionARM session, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyDataGraphPipelineSessionARM"); + device_dispatch_table(device)->DestroyDataGraphPipelineSessionARM(device, session, pAllocator); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchDataGraphARM(VkCommandBuffer commandBuffer, VkDataGraphPipelineSessionARM session, const VkDataGraphPipelineDispatchInfoARM* pInfo) { + Timer timer("vkCmdDispatchDataGraphARM"); + device_dispatch_table(commandBuffer)->CmdDispatchDataGraphARM(commandBuffer, session, pInfo); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetDataGraphPipelineAvailablePropertiesARM(VkDevice device, const VkDataGraphPipelineInfoARM* pPipelineInfo, uint32_t* pPropertiesCount, VkDataGraphPipelinePropertyARM* pProperties) { + Timer timer("vkGetDataGraphPipelineAvailablePropertiesARM"); + VkResult result = device_dispatch_table(device)->GetDataGraphPipelineAvailablePropertiesARM(device, pPipelineInfo, pPropertiesCount, pProperties); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetDataGraphPipelinePropertiesARM(VkDevice device, const VkDataGraphPipelineInfoARM* pPipelineInfo, uint32_t propertiesCount, VkDataGraphPipelinePropertyQueryResultARM* pProperties) { + Timer timer("vkGetDataGraphPipelinePropertiesARM"); + VkResult result = device_dispatch_table(device)->GetDataGraphPipelinePropertiesARM(device, pPipelineInfo, propertiesCount, pProperties); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetAttachmentFeedbackLoopEnableEXT(VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask) { + Timer timer("vkCmdSetAttachmentFeedbackLoopEnableEXT"); + device_dispatch_table(commandBuffer)->CmdSetAttachmentFeedbackLoopEnableEXT(commandBuffer, aspectMask); +} +#if defined(VK_USE_PLATFORM_SCREEN_QNX) +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetScreenBufferPropertiesQNX(VkDevice device, const struct _screen_buffer* buffer, VkScreenBufferPropertiesQNX* pProperties) { + Timer timer("vkGetScreenBufferPropertiesQNX"); + VkResult result = device_dispatch_table(device)->GetScreenBufferPropertiesQNX(device, buffer, pProperties); + return result; +} +#endif // VK_USE_PLATFORM_SCREEN_QNX +template +VKAPI_ATTR void VKAPI_CALL vkCmdBindTileMemoryQCOM(VkCommandBuffer commandBuffer, const VkTileMemoryBindInfoQCOM* pTileMemoryBindInfo) { + Timer timer("vkCmdBindTileMemoryQCOM"); + device_dispatch_table(commandBuffer)->CmdBindTileMemoryQCOM(commandBuffer, pTileMemoryBindInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdDecompressMemoryEXT(VkCommandBuffer commandBuffer, const VkDecompressMemoryInfoEXT* pDecompressMemoryInfoEXT) { + Timer timer("vkCmdDecompressMemoryEXT"); + device_dispatch_table(commandBuffer)->CmdDecompressMemoryEXT(commandBuffer, pDecompressMemoryInfoEXT); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdDecompressMemoryIndirectCountEXT(VkCommandBuffer commandBuffer, VkMemoryDecompressionMethodFlagsEXT decompressionMethod, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t maxDecompressionCount, uint32_t stride) { + Timer timer("vkCmdDecompressMemoryIndirectCountEXT"); + device_dispatch_table(commandBuffer)->CmdDecompressMemoryIndirectCountEXT(commandBuffer, decompressionMethod, indirectCommandsAddress, indirectCommandsCountAddress, maxDecompressionCount, stride); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateExternalComputeQueueNV(VkDevice device, const VkExternalComputeQueueCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkExternalComputeQueueNV* pExternalQueue) { + Timer timer("vkCreateExternalComputeQueueNV"); + VkResult result = device_dispatch_table(device)->CreateExternalComputeQueueNV(device, pCreateInfo, pAllocator, pExternalQueue); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyExternalComputeQueueNV(VkDevice device, VkExternalComputeQueueNV externalQueue, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyExternalComputeQueueNV"); + device_dispatch_table(device)->DestroyExternalComputeQueueNV(device, externalQueue, pAllocator); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetExternalComputeQueueDataNV(VkExternalComputeQueueNV externalQueue, VkExternalComputeQueueDataParamsNV* params, void* pData) { + Timer timer("vkGetExternalComputeQueueDataNV"); + device_dispatch_table(externalQueue)->GetExternalComputeQueueDataNV(externalQueue, params, pData); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetClusterAccelerationStructureBuildSizesNV(VkDevice device, const VkClusterAccelerationStructureInputInfoNV* pInfo, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) { + Timer timer("vkGetClusterAccelerationStructureBuildSizesNV"); + device_dispatch_table(device)->GetClusterAccelerationStructureBuildSizesNV(device, pInfo, pSizeInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdBuildClusterAccelerationStructureIndirectNV(VkCommandBuffer commandBuffer, const VkClusterAccelerationStructureCommandsInfoNV* pCommandInfos) { + Timer timer("vkCmdBuildClusterAccelerationStructureIndirectNV"); + device_dispatch_table(commandBuffer)->CmdBuildClusterAccelerationStructureIndirectNV(commandBuffer, pCommandInfos); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetPartitionedAccelerationStructuresBuildSizesNV(VkDevice device, const VkPartitionedAccelerationStructureInstancesInputNV* pInfo, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) { + Timer timer("vkGetPartitionedAccelerationStructuresBuildSizesNV"); + device_dispatch_table(device)->GetPartitionedAccelerationStructuresBuildSizesNV(device, pInfo, pSizeInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdBuildPartitionedAccelerationStructuresNV(VkCommandBuffer commandBuffer, const VkBuildPartitionedAccelerationStructureInfoNV* pBuildInfo) { + Timer timer("vkCmdBuildPartitionedAccelerationStructuresNV"); + device_dispatch_table(commandBuffer)->CmdBuildPartitionedAccelerationStructuresNV(commandBuffer, pBuildInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetGeneratedCommandsMemoryRequirementsEXT(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoEXT* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + Timer timer("vkGetGeneratedCommandsMemoryRequirementsEXT"); + device_dispatch_table(device)->GetGeneratedCommandsMemoryRequirementsEXT(device, pInfo, pMemoryRequirements); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdPreprocessGeneratedCommandsEXT(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo, VkCommandBuffer stateCommandBuffer) { + Timer timer("vkCmdPreprocessGeneratedCommandsEXT"); + device_dispatch_table(commandBuffer)->CmdPreprocessGeneratedCommandsEXT(commandBuffer, pGeneratedCommandsInfo, stateCommandBuffer); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdExecuteGeneratedCommandsEXT(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo) { + Timer timer("vkCmdExecuteGeneratedCommandsEXT"); + device_dispatch_table(commandBuffer)->CmdExecuteGeneratedCommandsEXT(commandBuffer, isPreprocessed, pGeneratedCommandsInfo); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutEXT(VkDevice device, const VkIndirectCommandsLayoutCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutEXT* pIndirectCommandsLayout) { + Timer timer("vkCreateIndirectCommandsLayoutEXT"); + VkResult result = device_dispatch_table(device)->CreateIndirectCommandsLayoutEXT(device, pCreateInfo, pAllocator, pIndirectCommandsLayout); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutEXT(VkDevice device, VkIndirectCommandsLayoutEXT indirectCommandsLayout, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyIndirectCommandsLayoutEXT"); + device_dispatch_table(device)->DestroyIndirectCommandsLayoutEXT(device, indirectCommandsLayout, pAllocator); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectExecutionSetEXT(VkDevice device, const VkIndirectExecutionSetCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectExecutionSetEXT* pIndirectExecutionSet) { + Timer timer("vkCreateIndirectExecutionSetEXT"); + VkResult result = device_dispatch_table(device)->CreateIndirectExecutionSetEXT(device, pCreateInfo, pAllocator, pIndirectExecutionSet); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectExecutionSetEXT(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyIndirectExecutionSetEXT"); + device_dispatch_table(device)->DestroyIndirectExecutionSetEXT(device, indirectExecutionSet, pAllocator); +} +template +VKAPI_ATTR void VKAPI_CALL vkUpdateIndirectExecutionSetPipelineEXT(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, const VkWriteIndirectExecutionSetPipelineEXT* pExecutionSetWrites) { + Timer timer("vkUpdateIndirectExecutionSetPipelineEXT"); + device_dispatch_table(device)->UpdateIndirectExecutionSetPipelineEXT(device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites); +} +template +VKAPI_ATTR void VKAPI_CALL vkUpdateIndirectExecutionSetShaderEXT(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, const VkWriteIndirectExecutionSetShaderEXT* pExecutionSetWrites) { + Timer timer("vkUpdateIndirectExecutionSetShaderEXT"); + device_dispatch_table(device)->UpdateIndirectExecutionSetShaderEXT(device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites); +} +#if defined(VK_USE_PLATFORM_METAL_EXT) +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryMetalHandleEXT(VkDevice device, const VkMemoryGetMetalHandleInfoEXT* pGetMetalHandleInfo, void** pHandle) { + Timer timer("vkGetMemoryMetalHandleEXT"); + VkResult result = device_dispatch_table(device)->GetMemoryMetalHandleEXT(device, pGetMetalHandleInfo, pHandle); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryMetalHandlePropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHandle, VkMemoryMetalHandlePropertiesEXT* pMemoryMetalHandleProperties) { + Timer timer("vkGetMemoryMetalHandlePropertiesEXT"); + VkResult result = device_dispatch_table(device)->GetMemoryMetalHandlePropertiesEXT(device, handleType, pHandle, pMemoryMetalHandleProperties); + return result; +} +#endif // VK_USE_PLATFORM_METAL_EXT +template +VKAPI_ATTR void VKAPI_CALL vkCmdEndRendering2EXT(VkCommandBuffer commandBuffer, const VkRenderingEndInfoKHR* pRenderingEndInfo) { + Timer timer("vkCmdEndRendering2EXT"); + device_dispatch_table(commandBuffer)->CmdEndRendering2EXT(commandBuffer, pRenderingEndInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdBeginCustomResolveEXT(VkCommandBuffer commandBuffer, const VkBeginCustomResolveInfoEXT* pBeginCustomResolveInfo) { + Timer timer("vkCmdBeginCustomResolveEXT"); + device_dispatch_table(commandBuffer)->CmdBeginCustomResolveEXT(commandBuffer, pBeginCustomResolveInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetComputeOccupancyPriorityNV(VkCommandBuffer commandBuffer, const VkComputeOccupancyPriorityParametersNV* pParameters) { + Timer timer("vkCmdSetComputeOccupancyPriorityNV"); + device_dispatch_table(commandBuffer)->CmdSetComputeOccupancyPriorityNV(commandBuffer, pParameters); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure) { + Timer timer("vkCreateAccelerationStructureKHR"); + VkResult result = device_dispatch_table(device)->CreateAccelerationStructureKHR(device, pCreateInfo, pAllocator, pAccelerationStructure); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkDestroyAccelerationStructureKHR(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks* pAllocator) { + Timer timer("vkDestroyAccelerationStructureKHR"); + device_dispatch_table(device)->DestroyAccelerationStructureKHR(device, accelerationStructure, pAllocator); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructuresKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) { + Timer timer("vkCmdBuildAccelerationStructuresKHR"); + device_dispatch_table(commandBuffer)->CmdBuildAccelerationStructuresKHR(commandBuffer, infoCount, pInfos, ppBuildRangeInfos); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructuresIndirectKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkDeviceAddress* pIndirectDeviceAddresses, const uint32_t* pIndirectStrides, const uint32_t* const* ppMaxPrimitiveCounts) { + Timer timer("vkCmdBuildAccelerationStructuresIndirectKHR"); + device_dispatch_table(commandBuffer)->CmdBuildAccelerationStructuresIndirectKHR(commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkBuildAccelerationStructuresKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) { + Timer timer("vkBuildAccelerationStructuresKHR"); + VkResult result = device_dispatch_table(device)->BuildAccelerationStructuresKHR(device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCopyAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR* pInfo) { + Timer timer("vkCopyAccelerationStructureKHR"); + VkResult result = device_dispatch_table(device)->CopyAccelerationStructureKHR(device, deferredOperation, pInfo); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCopyAccelerationStructureToMemoryKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) { + Timer timer("vkCopyAccelerationStructureToMemoryKHR"); + VkResult result = device_dispatch_table(device)->CopyAccelerationStructureToMemoryKHR(device, deferredOperation, pInfo); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) { + Timer timer("vkCopyMemoryToAccelerationStructureKHR"); + VkResult result = device_dispatch_table(device)->CopyMemoryToAccelerationStructureKHR(device, deferredOperation, pInfo); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkWriteAccelerationStructuresPropertiesKHR(VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, size_t dataSize, void* pData, size_t stride) { + Timer timer("vkWriteAccelerationStructuresPropertiesKHR"); + VkResult result = device_dispatch_table(device)->WriteAccelerationStructuresPropertiesKHR(device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR* pInfo) { + Timer timer("vkCmdCopyAccelerationStructureKHR"); + device_dispatch_table(commandBuffer)->CmdCopyAccelerationStructureKHR(commandBuffer, pInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureToMemoryKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) { + Timer timer("vkCmdCopyAccelerationStructureToMemoryKHR"); + device_dispatch_table(commandBuffer)->CmdCopyAccelerationStructureToMemoryKHR(commandBuffer, pInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) { + Timer timer("vkCmdCopyMemoryToAccelerationStructureKHR"); + device_dispatch_table(commandBuffer)->CmdCopyMemoryToAccelerationStructureKHR(commandBuffer, pInfo); +} +template +VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetAccelerationStructureDeviceAddressKHR(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo) { + Timer timer("vkGetAccelerationStructureDeviceAddressKHR"); + VkDeviceAddress result = device_dispatch_table(device)->GetAccelerationStructureDeviceAddressKHR(device, pInfo); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdWriteAccelerationStructuresPropertiesKHR(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) { + Timer timer("vkCmdWriteAccelerationStructuresPropertiesKHR"); + device_dispatch_table(commandBuffer)->CmdWriteAccelerationStructuresPropertiesKHR(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetDeviceAccelerationStructureCompatibilityKHR(VkDevice device, const VkAccelerationStructureVersionInfoKHR* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility) { + Timer timer("vkGetDeviceAccelerationStructureCompatibilityKHR"); + device_dispatch_table(device)->GetDeviceAccelerationStructureCompatibilityKHR(device, pVersionInfo, pCompatibility); +} +template +VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureBuildSizesKHR(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) { + Timer timer("vkGetAccelerationStructureBuildSizesKHR"); + device_dispatch_table(device)->GetAccelerationStructureBuildSizesKHR(device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth) { + Timer timer("vkCmdTraceRaysKHR"); + device_dispatch_table(commandBuffer)->CmdTraceRaysKHR(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth); +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkCreateRayTracingPipelinesKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { + Timer timer("vkCreateRayTracingPipelinesKHR"); + VkResult result = device_dispatch_table(device)->CreateRayTracingPipelinesKHR(device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + return result; +} +template +VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) { + Timer timer("vkGetRayTracingCaptureReplayShaderGroupHandlesKHR"); + VkResult result = device_dispatch_table(device)->GetRayTracingCaptureReplayShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount, dataSize, pData); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysIndirectKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress) { + Timer timer("vkCmdTraceRaysIndirectKHR"); + device_dispatch_table(commandBuffer)->CmdTraceRaysIndirectKHR(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress); +} +template +VKAPI_ATTR VkDeviceSize VKAPI_CALL vkGetRayTracingShaderGroupStackSizeKHR(VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader) { + Timer timer("vkGetRayTracingShaderGroupStackSizeKHR"); + VkDeviceSize result = device_dispatch_table(device)->GetRayTracingShaderGroupStackSizeKHR(device, pipeline, group, groupShader); + return result; +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize) { + Timer timer("vkCmdSetRayTracingPipelineStackSizeKHR"); + device_dispatch_table(commandBuffer)->CmdSetRayTracingPipelineStackSizeKHR(commandBuffer, pipelineStackSize); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksEXT(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) { + Timer timer("vkCmdDrawMeshTasksEXT"); + device_dispatch_table(commandBuffer)->CmdDrawMeshTasksEXT(commandBuffer, groupCountX, groupCountY, groupCountZ); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectEXT(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) { + Timer timer("vkCmdDrawMeshTasksIndirectEXT"); + device_dispatch_table(commandBuffer)->CmdDrawMeshTasksIndirectEXT(commandBuffer, buffer, offset, drawCount, stride); +} +template +VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectCountEXT(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { + Timer timer("vkCmdDrawMeshTasksIndirectCountEXT"); + device_dispatch_table(commandBuffer)->CmdDrawMeshTasksIndirectCountEXT(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); +} + +template +VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL api_dump_known_instance_functions(VkInstance instance, const char* pName) { + if (strcmp(pName, "vkCreateInstance") == 0) + return reinterpret_cast(vkCreateInstance); + if (strcmp(pName, "vkDestroyInstance") == 0) + return reinterpret_cast(vkDestroyInstance); + if (strcmp(pName, "vkEnumeratePhysicalDevices") == 0) + return reinterpret_cast(vkEnumeratePhysicalDevices); + if (strcmp(pName, "vkGetPhysicalDeviceFeatures") == 0) + return reinterpret_cast(vkGetPhysicalDeviceFeatures); + if (strcmp(pName, "vkGetPhysicalDeviceFormatProperties") == 0) + return reinterpret_cast(vkGetPhysicalDeviceFormatProperties); + if (strcmp(pName, "vkGetPhysicalDeviceImageFormatProperties") == 0) + return reinterpret_cast(vkGetPhysicalDeviceImageFormatProperties); + if (strcmp(pName, "vkGetPhysicalDeviceProperties") == 0) + return reinterpret_cast(vkGetPhysicalDeviceProperties); + if (strcmp(pName, "vkGetPhysicalDeviceQueueFamilyProperties") == 0) + return reinterpret_cast(vkGetPhysicalDeviceQueueFamilyProperties); + if (strcmp(pName, "vkGetPhysicalDeviceMemoryProperties") == 0) + return reinterpret_cast(vkGetPhysicalDeviceMemoryProperties); + if (strcmp(pName, "vkGetInstanceProcAddr") == 0) + return reinterpret_cast(vkGetInstanceProcAddr); + if (strcmp(pName, "vkCreateDevice") == 0) + return reinterpret_cast(vkCreateDevice); + if (strcmp(pName, "vkEnumerateInstanceExtensionProperties") == 0) + return reinterpret_cast(vkEnumerateInstanceExtensionProperties); + if (strcmp(pName, "vkEnumerateInstanceLayerProperties") == 0) + return reinterpret_cast(vkEnumerateInstanceLayerProperties); + if (strcmp(pName, "vkEnumerateDeviceLayerProperties") == 0) + return reinterpret_cast(vkEnumerateDeviceLayerProperties); + if (strcmp(pName, "vkGetPhysicalDeviceSparseImageFormatProperties") == 0) + return reinterpret_cast(vkGetPhysicalDeviceSparseImageFormatProperties); + if (strcmp(pName, "vkEnumeratePhysicalDeviceGroups") == 0) + return reinterpret_cast(vkEnumeratePhysicalDeviceGroups); + if (strcmp(pName, "vkGetPhysicalDeviceFeatures2") == 0) + return reinterpret_cast(vkGetPhysicalDeviceFeatures2); + if (strcmp(pName, "vkGetPhysicalDeviceProperties2") == 0) + return reinterpret_cast(vkGetPhysicalDeviceProperties2); + if (strcmp(pName, "vkGetPhysicalDeviceFormatProperties2") == 0) + return reinterpret_cast(vkGetPhysicalDeviceFormatProperties2); + if (strcmp(pName, "vkGetPhysicalDeviceImageFormatProperties2") == 0) + return reinterpret_cast(vkGetPhysicalDeviceImageFormatProperties2); + if (strcmp(pName, "vkGetPhysicalDeviceQueueFamilyProperties2") == 0) + return reinterpret_cast(vkGetPhysicalDeviceQueueFamilyProperties2); + if (strcmp(pName, "vkGetPhysicalDeviceMemoryProperties2") == 0) + return reinterpret_cast(vkGetPhysicalDeviceMemoryProperties2); + if (strcmp(pName, "vkGetPhysicalDeviceSparseImageFormatProperties2") == 0) + return reinterpret_cast(vkGetPhysicalDeviceSparseImageFormatProperties2); + if (strcmp(pName, "vkGetPhysicalDeviceExternalBufferProperties") == 0) + return reinterpret_cast(vkGetPhysicalDeviceExternalBufferProperties); + if (strcmp(pName, "vkGetPhysicalDeviceExternalFenceProperties") == 0) + return reinterpret_cast(vkGetPhysicalDeviceExternalFenceProperties); + if (strcmp(pName, "vkGetPhysicalDeviceExternalSemaphoreProperties") == 0) + return reinterpret_cast(vkGetPhysicalDeviceExternalSemaphoreProperties); + if (strcmp(pName, "vkGetPhysicalDeviceToolProperties") == 0) + return reinterpret_cast(vkGetPhysicalDeviceToolProperties); + if (strcmp(pName, "vkDestroySurfaceKHR") == 0) + return reinterpret_cast(vkDestroySurfaceKHR); + if (strcmp(pName, "vkGetPhysicalDeviceSurfaceSupportKHR") == 0) + return reinterpret_cast(vkGetPhysicalDeviceSurfaceSupportKHR); + if (strcmp(pName, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR") == 0) + return reinterpret_cast(vkGetPhysicalDeviceSurfaceCapabilitiesKHR); + if (strcmp(pName, "vkGetPhysicalDeviceSurfaceFormatsKHR") == 0) + return reinterpret_cast(vkGetPhysicalDeviceSurfaceFormatsKHR); + if (strcmp(pName, "vkGetPhysicalDeviceSurfacePresentModesKHR") == 0) + return reinterpret_cast(vkGetPhysicalDeviceSurfacePresentModesKHR); + if (strcmp(pName, "vkGetPhysicalDevicePresentRectanglesKHR") == 0) + return reinterpret_cast(vkGetPhysicalDevicePresentRectanglesKHR); + if (strcmp(pName, "vkGetPhysicalDeviceDisplayPropertiesKHR") == 0) + return reinterpret_cast(vkGetPhysicalDeviceDisplayPropertiesKHR); + if (strcmp(pName, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR") == 0) + return reinterpret_cast(vkGetPhysicalDeviceDisplayPlanePropertiesKHR); + if (strcmp(pName, "vkGetDisplayPlaneSupportedDisplaysKHR") == 0) + return reinterpret_cast(vkGetDisplayPlaneSupportedDisplaysKHR); + if (strcmp(pName, "vkGetDisplayModePropertiesKHR") == 0) + return reinterpret_cast(vkGetDisplayModePropertiesKHR); + if (strcmp(pName, "vkCreateDisplayModeKHR") == 0) + return reinterpret_cast(vkCreateDisplayModeKHR); + if (strcmp(pName, "vkGetDisplayPlaneCapabilitiesKHR") == 0) + return reinterpret_cast(vkGetDisplayPlaneCapabilitiesKHR); + if (strcmp(pName, "vkCreateDisplayPlaneSurfaceKHR") == 0) + return reinterpret_cast(vkCreateDisplayPlaneSurfaceKHR); +#if defined(VK_USE_PLATFORM_XLIB_KHR) + if (strcmp(pName, "vkCreateXlibSurfaceKHR") == 0) + return reinterpret_cast(vkCreateXlibSurfaceKHR); + if (strcmp(pName, "vkGetPhysicalDeviceXlibPresentationSupportKHR") == 0) + return reinterpret_cast(vkGetPhysicalDeviceXlibPresentationSupportKHR); +#endif // VK_USE_PLATFORM_XLIB_KHR +#if defined(VK_USE_PLATFORM_XCB_KHR) + if (strcmp(pName, "vkCreateXcbSurfaceKHR") == 0) + return reinterpret_cast(vkCreateXcbSurfaceKHR); + if (strcmp(pName, "vkGetPhysicalDeviceXcbPresentationSupportKHR") == 0) + return reinterpret_cast(vkGetPhysicalDeviceXcbPresentationSupportKHR); +#endif // VK_USE_PLATFORM_XCB_KHR +#if defined(VK_USE_PLATFORM_WAYLAND_KHR) + if (strcmp(pName, "vkCreateWaylandSurfaceKHR") == 0) + return reinterpret_cast(vkCreateWaylandSurfaceKHR); + if (strcmp(pName, "vkGetPhysicalDeviceWaylandPresentationSupportKHR") == 0) + return reinterpret_cast(vkGetPhysicalDeviceWaylandPresentationSupportKHR); +#endif // VK_USE_PLATFORM_WAYLAND_KHR +#if defined(VK_USE_PLATFORM_ANDROID_KHR) + if (strcmp(pName, "vkCreateAndroidSurfaceKHR") == 0) + return reinterpret_cast(vkCreateAndroidSurfaceKHR); +#endif // VK_USE_PLATFORM_ANDROID_KHR +#if defined(VK_USE_PLATFORM_WIN32_KHR) + if (strcmp(pName, "vkCreateWin32SurfaceKHR") == 0) + return reinterpret_cast(vkCreateWin32SurfaceKHR); + if (strcmp(pName, "vkGetPhysicalDeviceWin32PresentationSupportKHR") == 0) + return reinterpret_cast(vkGetPhysicalDeviceWin32PresentationSupportKHR); +#endif // VK_USE_PLATFORM_WIN32_KHR + if (strcmp(pName, "vkGetPhysicalDeviceVideoCapabilitiesKHR") == 0) + return reinterpret_cast(vkGetPhysicalDeviceVideoCapabilitiesKHR); + if (strcmp(pName, "vkGetPhysicalDeviceVideoFormatPropertiesKHR") == 0) + return reinterpret_cast(vkGetPhysicalDeviceVideoFormatPropertiesKHR); + if (strcmp(pName, "vkGetPhysicalDeviceFeatures2KHR") == 0) + return reinterpret_cast(vkGetPhysicalDeviceFeatures2KHR); + if (strcmp(pName, "vkGetPhysicalDeviceProperties2KHR") == 0) + return reinterpret_cast(vkGetPhysicalDeviceProperties2KHR); + if (strcmp(pName, "vkGetPhysicalDeviceFormatProperties2KHR") == 0) + return reinterpret_cast(vkGetPhysicalDeviceFormatProperties2KHR); + if (strcmp(pName, "vkGetPhysicalDeviceImageFormatProperties2KHR") == 0) + return reinterpret_cast(vkGetPhysicalDeviceImageFormatProperties2KHR); + if (strcmp(pName, "vkGetPhysicalDeviceQueueFamilyProperties2KHR") == 0) + return reinterpret_cast(vkGetPhysicalDeviceQueueFamilyProperties2KHR); + if (strcmp(pName, "vkGetPhysicalDeviceMemoryProperties2KHR") == 0) + return reinterpret_cast(vkGetPhysicalDeviceMemoryProperties2KHR); + if (strcmp(pName, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR") == 0) + return reinterpret_cast(vkGetPhysicalDeviceSparseImageFormatProperties2KHR); + if (strcmp(pName, "vkEnumeratePhysicalDeviceGroupsKHR") == 0) + return reinterpret_cast(vkEnumeratePhysicalDeviceGroupsKHR); + if (strcmp(pName, "vkGetPhysicalDeviceExternalBufferPropertiesKHR") == 0) + return reinterpret_cast(vkGetPhysicalDeviceExternalBufferPropertiesKHR); + if (strcmp(pName, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR") == 0) + return reinterpret_cast(vkGetPhysicalDeviceExternalSemaphorePropertiesKHR); + if (strcmp(pName, "vkGetPhysicalDeviceExternalFencePropertiesKHR") == 0) + return reinterpret_cast(vkGetPhysicalDeviceExternalFencePropertiesKHR); + if (strcmp(pName, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR") == 0) + return reinterpret_cast(vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR); + if (strcmp(pName, "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR") == 0) + return reinterpret_cast(vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR); + if (strcmp(pName, "vkGetPhysicalDeviceSurfaceCapabilities2KHR") == 0) + return reinterpret_cast(vkGetPhysicalDeviceSurfaceCapabilities2KHR); + if (strcmp(pName, "vkGetPhysicalDeviceSurfaceFormats2KHR") == 0) + return reinterpret_cast(vkGetPhysicalDeviceSurfaceFormats2KHR); + if (strcmp(pName, "vkGetPhysicalDeviceDisplayProperties2KHR") == 0) + return reinterpret_cast(vkGetPhysicalDeviceDisplayProperties2KHR); + if (strcmp(pName, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR") == 0) + return reinterpret_cast(vkGetPhysicalDeviceDisplayPlaneProperties2KHR); + if (strcmp(pName, "vkGetDisplayModeProperties2KHR") == 0) + return reinterpret_cast(vkGetDisplayModeProperties2KHR); + if (strcmp(pName, "vkGetDisplayPlaneCapabilities2KHR") == 0) + return reinterpret_cast(vkGetDisplayPlaneCapabilities2KHR); + if (strcmp(pName, "vkGetPhysicalDeviceFragmentShadingRatesKHR") == 0) + return reinterpret_cast(vkGetPhysicalDeviceFragmentShadingRatesKHR); + if (strcmp(pName, "vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR") == 0) + return reinterpret_cast(vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR); + if (strcmp(pName, "vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR") == 0) + return reinterpret_cast(vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR); + if (strcmp(pName, "vkGetPhysicalDeviceCalibrateableTimeDomainsKHR") == 0) + return reinterpret_cast(vkGetPhysicalDeviceCalibrateableTimeDomainsKHR); + if (strcmp(pName, "vkCreateDebugReportCallbackEXT") == 0) + return reinterpret_cast(vkCreateDebugReportCallbackEXT); + if (strcmp(pName, "vkDestroyDebugReportCallbackEXT") == 0) + return reinterpret_cast(vkDestroyDebugReportCallbackEXT); + if (strcmp(pName, "vkDebugReportMessageEXT") == 0) + return reinterpret_cast(vkDebugReportMessageEXT); +#if defined(VK_USE_PLATFORM_GGP) + if (strcmp(pName, "vkCreateStreamDescriptorSurfaceGGP") == 0) + return reinterpret_cast(vkCreateStreamDescriptorSurfaceGGP); +#endif // VK_USE_PLATFORM_GGP + if (strcmp(pName, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV") == 0) + return reinterpret_cast(vkGetPhysicalDeviceExternalImageFormatPropertiesNV); +#if defined(VK_USE_PLATFORM_VI_NN) + if (strcmp(pName, "vkCreateViSurfaceNN") == 0) + return reinterpret_cast(vkCreateViSurfaceNN); +#endif // VK_USE_PLATFORM_VI_NN + if (strcmp(pName, "vkReleaseDisplayEXT") == 0) + return reinterpret_cast(vkReleaseDisplayEXT); +#if defined(VK_USE_PLATFORM_XLIB_XRANDR_EXT) + if (strcmp(pName, "vkAcquireXlibDisplayEXT") == 0) + return reinterpret_cast(vkAcquireXlibDisplayEXT); + if (strcmp(pName, "vkGetRandROutputDisplayEXT") == 0) + return reinterpret_cast(vkGetRandROutputDisplayEXT); +#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT + if (strcmp(pName, "vkGetPhysicalDeviceSurfaceCapabilities2EXT") == 0) + return reinterpret_cast(vkGetPhysicalDeviceSurfaceCapabilities2EXT); +#if defined(VK_USE_PLATFORM_IOS_MVK) + if (strcmp(pName, "vkCreateIOSSurfaceMVK") == 0) + return reinterpret_cast(vkCreateIOSSurfaceMVK); +#endif // VK_USE_PLATFORM_IOS_MVK +#if defined(VK_USE_PLATFORM_MACOS_MVK) + if (strcmp(pName, "vkCreateMacOSSurfaceMVK") == 0) + return reinterpret_cast(vkCreateMacOSSurfaceMVK); +#endif // VK_USE_PLATFORM_MACOS_MVK + if (strcmp(pName, "vkSetDebugUtilsObjectNameEXT") == 0) + return reinterpret_cast(vkSetDebugUtilsObjectNameEXT); + if (strcmp(pName, "vkSetDebugUtilsObjectTagEXT") == 0) + return reinterpret_cast(vkSetDebugUtilsObjectTagEXT); + if (strcmp(pName, "vkQueueBeginDebugUtilsLabelEXT") == 0) + return reinterpret_cast(vkQueueBeginDebugUtilsLabelEXT); + if (strcmp(pName, "vkQueueEndDebugUtilsLabelEXT") == 0) + return reinterpret_cast(vkQueueEndDebugUtilsLabelEXT); + if (strcmp(pName, "vkQueueInsertDebugUtilsLabelEXT") == 0) + return reinterpret_cast(vkQueueInsertDebugUtilsLabelEXT); + if (strcmp(pName, "vkCmdBeginDebugUtilsLabelEXT") == 0) + return reinterpret_cast(vkCmdBeginDebugUtilsLabelEXT); + if (strcmp(pName, "vkCmdEndDebugUtilsLabelEXT") == 0) + return reinterpret_cast(vkCmdEndDebugUtilsLabelEXT); + if (strcmp(pName, "vkCmdInsertDebugUtilsLabelEXT") == 0) + return reinterpret_cast(vkCmdInsertDebugUtilsLabelEXT); + if (strcmp(pName, "vkCreateDebugUtilsMessengerEXT") == 0) + return reinterpret_cast(vkCreateDebugUtilsMessengerEXT); + if (strcmp(pName, "vkDestroyDebugUtilsMessengerEXT") == 0) + return reinterpret_cast(vkDestroyDebugUtilsMessengerEXT); + if (strcmp(pName, "vkSubmitDebugUtilsMessageEXT") == 0) + return reinterpret_cast(vkSubmitDebugUtilsMessageEXT); + if (strcmp(pName, "vkGetPhysicalDeviceDescriptorSizeEXT") == 0) + return reinterpret_cast(vkGetPhysicalDeviceDescriptorSizeEXT); + if (strcmp(pName, "vkGetPhysicalDeviceMultisamplePropertiesEXT") == 0) + return reinterpret_cast(vkGetPhysicalDeviceMultisamplePropertiesEXT); + if (strcmp(pName, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT") == 0) + return reinterpret_cast(vkGetPhysicalDeviceCalibrateableTimeDomainsEXT); +#if defined(VK_USE_PLATFORM_FUCHSIA) + if (strcmp(pName, "vkCreateImagePipeSurfaceFUCHSIA") == 0) + return reinterpret_cast(vkCreateImagePipeSurfaceFUCHSIA); +#endif // VK_USE_PLATFORM_FUCHSIA +#if defined(VK_USE_PLATFORM_METAL_EXT) + if (strcmp(pName, "vkCreateMetalSurfaceEXT") == 0) + return reinterpret_cast(vkCreateMetalSurfaceEXT); +#endif // VK_USE_PLATFORM_METAL_EXT + if (strcmp(pName, "vkGetPhysicalDeviceToolPropertiesEXT") == 0) + return reinterpret_cast(vkGetPhysicalDeviceToolPropertiesEXT); + if (strcmp(pName, "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV") == 0) + return reinterpret_cast(vkGetPhysicalDeviceCooperativeMatrixPropertiesNV); + if (strcmp(pName, "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV") == 0) + return reinterpret_cast(vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV); +#if defined(VK_USE_PLATFORM_WIN32_KHR) + if (strcmp(pName, "vkGetPhysicalDeviceSurfacePresentModes2EXT") == 0) + return reinterpret_cast(vkGetPhysicalDeviceSurfacePresentModes2EXT); +#endif // VK_USE_PLATFORM_WIN32_KHR + if (strcmp(pName, "vkCreateHeadlessSurfaceEXT") == 0) + return reinterpret_cast(vkCreateHeadlessSurfaceEXT); + if (strcmp(pName, "vkAcquireDrmDisplayEXT") == 0) + return reinterpret_cast(vkAcquireDrmDisplayEXT); + if (strcmp(pName, "vkGetDrmDisplayEXT") == 0) + return reinterpret_cast(vkGetDrmDisplayEXT); +#if defined(VK_USE_PLATFORM_WIN32_KHR) + if (strcmp(pName, "vkAcquireWinrtDisplayNV") == 0) + return reinterpret_cast(vkAcquireWinrtDisplayNV); + if (strcmp(pName, "vkGetWinrtDisplayNV") == 0) + return reinterpret_cast(vkGetWinrtDisplayNV); +#endif // VK_USE_PLATFORM_WIN32_KHR +#if defined(VK_USE_PLATFORM_DIRECTFB_EXT) + if (strcmp(pName, "vkCreateDirectFBSurfaceEXT") == 0) + return reinterpret_cast(vkCreateDirectFBSurfaceEXT); + if (strcmp(pName, "vkGetPhysicalDeviceDirectFBPresentationSupportEXT") == 0) + return reinterpret_cast(vkGetPhysicalDeviceDirectFBPresentationSupportEXT); +#endif // VK_USE_PLATFORM_DIRECTFB_EXT +#if defined(VK_USE_PLATFORM_SCREEN_QNX) + if (strcmp(pName, "vkCreateScreenSurfaceQNX") == 0) + return reinterpret_cast(vkCreateScreenSurfaceQNX); + if (strcmp(pName, "vkGetPhysicalDeviceScreenPresentationSupportQNX") == 0) + return reinterpret_cast(vkGetPhysicalDeviceScreenPresentationSupportQNX); +#endif // VK_USE_PLATFORM_SCREEN_QNX + if (strcmp(pName, "vkGetPhysicalDeviceExternalTensorPropertiesARM") == 0) + return reinterpret_cast(vkGetPhysicalDeviceExternalTensorPropertiesARM); + if (strcmp(pName, "vkGetPhysicalDeviceOpticalFlowImageFormatsNV") == 0) + return reinterpret_cast(vkGetPhysicalDeviceOpticalFlowImageFormatsNV); + if (strcmp(pName, "vkGetPhysicalDeviceCooperativeVectorPropertiesNV") == 0) + return reinterpret_cast(vkGetPhysicalDeviceCooperativeVectorPropertiesNV); + if (strcmp(pName, "vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM") == 0) + return reinterpret_cast(vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM); + if (strcmp(pName, "vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM") == 0) + return reinterpret_cast(vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM); +#if defined(VK_USE_PLATFORM_OHOS) + if (strcmp(pName, "vkCreateSurfaceOHOS") == 0) + return reinterpret_cast(vkCreateSurfaceOHOS); +#endif // VK_USE_PLATFORM_OHOS + if (strcmp(pName, "vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV") == 0) + return reinterpret_cast(vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV); + if (strcmp(pName, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM") == 0) + return reinterpret_cast(vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM); + + return nullptr; +} + +template +VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL api_dump_known_device_functions(VkDevice device, const char* pName) { + if (strcmp(pName, "vkGetDeviceProcAddr") == 0 && (!device || device_dispatch_table(device)->GetDeviceProcAddr)) + return reinterpret_cast(vkGetDeviceProcAddr); + if (strcmp(pName, "vkDestroyDevice") == 0 && (!device || device_dispatch_table(device)->DestroyDevice)) + return reinterpret_cast(vkDestroyDevice); + if (strcmp(pName, "vkGetDeviceQueue") == 0 && (!device || device_dispatch_table(device)->GetDeviceQueue)) + return reinterpret_cast(vkGetDeviceQueue); + if (strcmp(pName, "vkQueueSubmit") == 0 && (!device || device_dispatch_table(device)->QueueSubmit)) + return reinterpret_cast(vkQueueSubmit); + if (strcmp(pName, "vkQueueWaitIdle") == 0 && (!device || device_dispatch_table(device)->QueueWaitIdle)) + return reinterpret_cast(vkQueueWaitIdle); + if (strcmp(pName, "vkDeviceWaitIdle") == 0 && (!device || device_dispatch_table(device)->DeviceWaitIdle)) + return reinterpret_cast(vkDeviceWaitIdle); + if (strcmp(pName, "vkAllocateMemory") == 0 && (!device || device_dispatch_table(device)->AllocateMemory)) + return reinterpret_cast(vkAllocateMemory); + if (strcmp(pName, "vkFreeMemory") == 0 && (!device || device_dispatch_table(device)->FreeMemory)) + return reinterpret_cast(vkFreeMemory); + if (strcmp(pName, "vkMapMemory") == 0 && (!device || device_dispatch_table(device)->MapMemory)) + return reinterpret_cast(vkMapMemory); + if (strcmp(pName, "vkUnmapMemory") == 0 && (!device || device_dispatch_table(device)->UnmapMemory)) + return reinterpret_cast(vkUnmapMemory); + if (strcmp(pName, "vkFlushMappedMemoryRanges") == 0 && (!device || device_dispatch_table(device)->FlushMappedMemoryRanges)) + return reinterpret_cast(vkFlushMappedMemoryRanges); + if (strcmp(pName, "vkInvalidateMappedMemoryRanges") == 0 && (!device || device_dispatch_table(device)->InvalidateMappedMemoryRanges)) + return reinterpret_cast(vkInvalidateMappedMemoryRanges); + if (strcmp(pName, "vkGetDeviceMemoryCommitment") == 0 && (!device || device_dispatch_table(device)->GetDeviceMemoryCommitment)) + return reinterpret_cast(vkGetDeviceMemoryCommitment); + if (strcmp(pName, "vkBindBufferMemory") == 0 && (!device || device_dispatch_table(device)->BindBufferMemory)) + return reinterpret_cast(vkBindBufferMemory); + if (strcmp(pName, "vkBindImageMemory") == 0 && (!device || device_dispatch_table(device)->BindImageMemory)) + return reinterpret_cast(vkBindImageMemory); + if (strcmp(pName, "vkGetBufferMemoryRequirements") == 0 && (!device || device_dispatch_table(device)->GetBufferMemoryRequirements)) + return reinterpret_cast(vkGetBufferMemoryRequirements); + if (strcmp(pName, "vkGetImageMemoryRequirements") == 0 && (!device || device_dispatch_table(device)->GetImageMemoryRequirements)) + return reinterpret_cast(vkGetImageMemoryRequirements); + if (strcmp(pName, "vkGetImageSparseMemoryRequirements") == 0 && (!device || device_dispatch_table(device)->GetImageSparseMemoryRequirements)) + return reinterpret_cast(vkGetImageSparseMemoryRequirements); + if (strcmp(pName, "vkQueueBindSparse") == 0 && (!device || device_dispatch_table(device)->QueueBindSparse)) + return reinterpret_cast(vkQueueBindSparse); + if (strcmp(pName, "vkCreateFence") == 0 && (!device || device_dispatch_table(device)->CreateFence)) + return reinterpret_cast(vkCreateFence); + if (strcmp(pName, "vkDestroyFence") == 0 && (!device || device_dispatch_table(device)->DestroyFence)) + return reinterpret_cast(vkDestroyFence); + if (strcmp(pName, "vkResetFences") == 0 && (!device || device_dispatch_table(device)->ResetFences)) + return reinterpret_cast(vkResetFences); + if (strcmp(pName, "vkGetFenceStatus") == 0 && (!device || device_dispatch_table(device)->GetFenceStatus)) + return reinterpret_cast(vkGetFenceStatus); + if (strcmp(pName, "vkWaitForFences") == 0 && (!device || device_dispatch_table(device)->WaitForFences)) + return reinterpret_cast(vkWaitForFences); + if (strcmp(pName, "vkCreateSemaphore") == 0 && (!device || device_dispatch_table(device)->CreateSemaphore)) + return reinterpret_cast(vkCreateSemaphore); + if (strcmp(pName, "vkDestroySemaphore") == 0 && (!device || device_dispatch_table(device)->DestroySemaphore)) + return reinterpret_cast(vkDestroySemaphore); + if (strcmp(pName, "vkCreateQueryPool") == 0 && (!device || device_dispatch_table(device)->CreateQueryPool)) + return reinterpret_cast(vkCreateQueryPool); + if (strcmp(pName, "vkDestroyQueryPool") == 0 && (!device || device_dispatch_table(device)->DestroyQueryPool)) + return reinterpret_cast(vkDestroyQueryPool); + if (strcmp(pName, "vkGetQueryPoolResults") == 0 && (!device || device_dispatch_table(device)->GetQueryPoolResults)) + return reinterpret_cast(vkGetQueryPoolResults); + if (strcmp(pName, "vkCreateBuffer") == 0 && (!device || device_dispatch_table(device)->CreateBuffer)) + return reinterpret_cast(vkCreateBuffer); + if (strcmp(pName, "vkDestroyBuffer") == 0 && (!device || device_dispatch_table(device)->DestroyBuffer)) + return reinterpret_cast(vkDestroyBuffer); + if (strcmp(pName, "vkCreateImage") == 0 && (!device || device_dispatch_table(device)->CreateImage)) + return reinterpret_cast(vkCreateImage); + if (strcmp(pName, "vkDestroyImage") == 0 && (!device || device_dispatch_table(device)->DestroyImage)) + return reinterpret_cast(vkDestroyImage); + if (strcmp(pName, "vkGetImageSubresourceLayout") == 0 && (!device || device_dispatch_table(device)->GetImageSubresourceLayout)) + return reinterpret_cast(vkGetImageSubresourceLayout); + if (strcmp(pName, "vkCreateImageView") == 0 && (!device || device_dispatch_table(device)->CreateImageView)) + return reinterpret_cast(vkCreateImageView); + if (strcmp(pName, "vkDestroyImageView") == 0 && (!device || device_dispatch_table(device)->DestroyImageView)) + return reinterpret_cast(vkDestroyImageView); + if (strcmp(pName, "vkCreateCommandPool") == 0 && (!device || device_dispatch_table(device)->CreateCommandPool)) + return reinterpret_cast(vkCreateCommandPool); + if (strcmp(pName, "vkDestroyCommandPool") == 0 && (!device || device_dispatch_table(device)->DestroyCommandPool)) + return reinterpret_cast(vkDestroyCommandPool); + if (strcmp(pName, "vkResetCommandPool") == 0 && (!device || device_dispatch_table(device)->ResetCommandPool)) + return reinterpret_cast(vkResetCommandPool); + if (strcmp(pName, "vkAllocateCommandBuffers") == 0 && (!device || device_dispatch_table(device)->AllocateCommandBuffers)) + return reinterpret_cast(vkAllocateCommandBuffers); + if (strcmp(pName, "vkFreeCommandBuffers") == 0 && (!device || device_dispatch_table(device)->FreeCommandBuffers)) + return reinterpret_cast(vkFreeCommandBuffers); + if (strcmp(pName, "vkBeginCommandBuffer") == 0 && (!device || device_dispatch_table(device)->BeginCommandBuffer)) + return reinterpret_cast(vkBeginCommandBuffer); + if (strcmp(pName, "vkEndCommandBuffer") == 0 && (!device || device_dispatch_table(device)->EndCommandBuffer)) + return reinterpret_cast(vkEndCommandBuffer); + if (strcmp(pName, "vkResetCommandBuffer") == 0 && (!device || device_dispatch_table(device)->ResetCommandBuffer)) + return reinterpret_cast(vkResetCommandBuffer); + if (strcmp(pName, "vkCmdCopyBuffer") == 0 && (!device || device_dispatch_table(device)->CmdCopyBuffer)) + return reinterpret_cast(vkCmdCopyBuffer); + if (strcmp(pName, "vkCmdCopyImage") == 0 && (!device || device_dispatch_table(device)->CmdCopyImage)) + return reinterpret_cast(vkCmdCopyImage); + if (strcmp(pName, "vkCmdCopyBufferToImage") == 0 && (!device || device_dispatch_table(device)->CmdCopyBufferToImage)) + return reinterpret_cast(vkCmdCopyBufferToImage); + if (strcmp(pName, "vkCmdCopyImageToBuffer") == 0 && (!device || device_dispatch_table(device)->CmdCopyImageToBuffer)) + return reinterpret_cast(vkCmdCopyImageToBuffer); + if (strcmp(pName, "vkCmdUpdateBuffer") == 0 && (!device || device_dispatch_table(device)->CmdUpdateBuffer)) + return reinterpret_cast(vkCmdUpdateBuffer); + if (strcmp(pName, "vkCmdFillBuffer") == 0 && (!device || device_dispatch_table(device)->CmdFillBuffer)) + return reinterpret_cast(vkCmdFillBuffer); + if (strcmp(pName, "vkCmdPipelineBarrier") == 0 && (!device || device_dispatch_table(device)->CmdPipelineBarrier)) + return reinterpret_cast(vkCmdPipelineBarrier); + if (strcmp(pName, "vkCmdBeginQuery") == 0 && (!device || device_dispatch_table(device)->CmdBeginQuery)) + return reinterpret_cast(vkCmdBeginQuery); + if (strcmp(pName, "vkCmdEndQuery") == 0 && (!device || device_dispatch_table(device)->CmdEndQuery)) + return reinterpret_cast(vkCmdEndQuery); + if (strcmp(pName, "vkCmdResetQueryPool") == 0 && (!device || device_dispatch_table(device)->CmdResetQueryPool)) + return reinterpret_cast(vkCmdResetQueryPool); + if (strcmp(pName, "vkCmdWriteTimestamp") == 0 && (!device || device_dispatch_table(device)->CmdWriteTimestamp)) + return reinterpret_cast(vkCmdWriteTimestamp); + if (strcmp(pName, "vkCmdCopyQueryPoolResults") == 0 && (!device || device_dispatch_table(device)->CmdCopyQueryPoolResults)) + return reinterpret_cast(vkCmdCopyQueryPoolResults); + if (strcmp(pName, "vkCmdExecuteCommands") == 0 && (!device || device_dispatch_table(device)->CmdExecuteCommands)) + return reinterpret_cast(vkCmdExecuteCommands); + if (strcmp(pName, "vkCreateEvent") == 0 && (!device || device_dispatch_table(device)->CreateEvent)) + return reinterpret_cast(vkCreateEvent); + if (strcmp(pName, "vkDestroyEvent") == 0 && (!device || device_dispatch_table(device)->DestroyEvent)) + return reinterpret_cast(vkDestroyEvent); + if (strcmp(pName, "vkGetEventStatus") == 0 && (!device || device_dispatch_table(device)->GetEventStatus)) + return reinterpret_cast(vkGetEventStatus); + if (strcmp(pName, "vkSetEvent") == 0 && (!device || device_dispatch_table(device)->SetEvent)) + return reinterpret_cast(vkSetEvent); + if (strcmp(pName, "vkResetEvent") == 0 && (!device || device_dispatch_table(device)->ResetEvent)) + return reinterpret_cast(vkResetEvent); + if (strcmp(pName, "vkCreateBufferView") == 0 && (!device || device_dispatch_table(device)->CreateBufferView)) + return reinterpret_cast(vkCreateBufferView); + if (strcmp(pName, "vkDestroyBufferView") == 0 && (!device || device_dispatch_table(device)->DestroyBufferView)) + return reinterpret_cast(vkDestroyBufferView); + if (strcmp(pName, "vkCreateShaderModule") == 0 && (!device || device_dispatch_table(device)->CreateShaderModule)) + return reinterpret_cast(vkCreateShaderModule); + if (strcmp(pName, "vkDestroyShaderModule") == 0 && (!device || device_dispatch_table(device)->DestroyShaderModule)) + return reinterpret_cast(vkDestroyShaderModule); + if (strcmp(pName, "vkCreatePipelineCache") == 0 && (!device || device_dispatch_table(device)->CreatePipelineCache)) + return reinterpret_cast(vkCreatePipelineCache); + if (strcmp(pName, "vkDestroyPipelineCache") == 0 && (!device || device_dispatch_table(device)->DestroyPipelineCache)) + return reinterpret_cast(vkDestroyPipelineCache); + if (strcmp(pName, "vkGetPipelineCacheData") == 0 && (!device || device_dispatch_table(device)->GetPipelineCacheData)) + return reinterpret_cast(vkGetPipelineCacheData); + if (strcmp(pName, "vkMergePipelineCaches") == 0 && (!device || device_dispatch_table(device)->MergePipelineCaches)) + return reinterpret_cast(vkMergePipelineCaches); + if (strcmp(pName, "vkCreateComputePipelines") == 0 && (!device || device_dispatch_table(device)->CreateComputePipelines)) + return reinterpret_cast(vkCreateComputePipelines); + if (strcmp(pName, "vkDestroyPipeline") == 0 && (!device || device_dispatch_table(device)->DestroyPipeline)) + return reinterpret_cast(vkDestroyPipeline); + if (strcmp(pName, "vkCreatePipelineLayout") == 0 && (!device || device_dispatch_table(device)->CreatePipelineLayout)) + return reinterpret_cast(vkCreatePipelineLayout); + if (strcmp(pName, "vkDestroyPipelineLayout") == 0 && (!device || device_dispatch_table(device)->DestroyPipelineLayout)) + return reinterpret_cast(vkDestroyPipelineLayout); + if (strcmp(pName, "vkCreateSampler") == 0 && (!device || device_dispatch_table(device)->CreateSampler)) + return reinterpret_cast(vkCreateSampler); + if (strcmp(pName, "vkDestroySampler") == 0 && (!device || device_dispatch_table(device)->DestroySampler)) + return reinterpret_cast(vkDestroySampler); + if (strcmp(pName, "vkCreateDescriptorSetLayout") == 0 && (!device || device_dispatch_table(device)->CreateDescriptorSetLayout)) + return reinterpret_cast(vkCreateDescriptorSetLayout); + if (strcmp(pName, "vkDestroyDescriptorSetLayout") == 0 && (!device || device_dispatch_table(device)->DestroyDescriptorSetLayout)) + return reinterpret_cast(vkDestroyDescriptorSetLayout); + if (strcmp(pName, "vkCreateDescriptorPool") == 0 && (!device || device_dispatch_table(device)->CreateDescriptorPool)) + return reinterpret_cast(vkCreateDescriptorPool); + if (strcmp(pName, "vkDestroyDescriptorPool") == 0 && (!device || device_dispatch_table(device)->DestroyDescriptorPool)) + return reinterpret_cast(vkDestroyDescriptorPool); + if (strcmp(pName, "vkResetDescriptorPool") == 0 && (!device || device_dispatch_table(device)->ResetDescriptorPool)) + return reinterpret_cast(vkResetDescriptorPool); + if (strcmp(pName, "vkAllocateDescriptorSets") == 0 && (!device || device_dispatch_table(device)->AllocateDescriptorSets)) + return reinterpret_cast(vkAllocateDescriptorSets); + if (strcmp(pName, "vkFreeDescriptorSets") == 0 && (!device || device_dispatch_table(device)->FreeDescriptorSets)) + return reinterpret_cast(vkFreeDescriptorSets); + if (strcmp(pName, "vkUpdateDescriptorSets") == 0 && (!device || device_dispatch_table(device)->UpdateDescriptorSets)) + return reinterpret_cast(vkUpdateDescriptorSets); + if (strcmp(pName, "vkCmdBindPipeline") == 0 && (!device || device_dispatch_table(device)->CmdBindPipeline)) + return reinterpret_cast(vkCmdBindPipeline); + if (strcmp(pName, "vkCmdBindDescriptorSets") == 0 && (!device || device_dispatch_table(device)->CmdBindDescriptorSets)) + return reinterpret_cast(vkCmdBindDescriptorSets); + if (strcmp(pName, "vkCmdClearColorImage") == 0 && (!device || device_dispatch_table(device)->CmdClearColorImage)) + return reinterpret_cast(vkCmdClearColorImage); + if (strcmp(pName, "vkCmdDispatch") == 0 && (!device || device_dispatch_table(device)->CmdDispatch)) + return reinterpret_cast(vkCmdDispatch); + if (strcmp(pName, "vkCmdDispatchIndirect") == 0 && (!device || device_dispatch_table(device)->CmdDispatchIndirect)) + return reinterpret_cast(vkCmdDispatchIndirect); + if (strcmp(pName, "vkCmdSetEvent") == 0 && (!device || device_dispatch_table(device)->CmdSetEvent)) + return reinterpret_cast(vkCmdSetEvent); + if (strcmp(pName, "vkCmdResetEvent") == 0 && (!device || device_dispatch_table(device)->CmdResetEvent)) + return reinterpret_cast(vkCmdResetEvent); + if (strcmp(pName, "vkCmdWaitEvents") == 0 && (!device || device_dispatch_table(device)->CmdWaitEvents)) + return reinterpret_cast(vkCmdWaitEvents); + if (strcmp(pName, "vkCmdPushConstants") == 0 && (!device || device_dispatch_table(device)->CmdPushConstants)) + return reinterpret_cast(vkCmdPushConstants); + if (strcmp(pName, "vkCreateGraphicsPipelines") == 0 && (!device || device_dispatch_table(device)->CreateGraphicsPipelines)) + return reinterpret_cast(vkCreateGraphicsPipelines); + if (strcmp(pName, "vkCreateFramebuffer") == 0 && (!device || device_dispatch_table(device)->CreateFramebuffer)) + return reinterpret_cast(vkCreateFramebuffer); + if (strcmp(pName, "vkDestroyFramebuffer") == 0 && (!device || device_dispatch_table(device)->DestroyFramebuffer)) + return reinterpret_cast(vkDestroyFramebuffer); + if (strcmp(pName, "vkCreateRenderPass") == 0 && (!device || device_dispatch_table(device)->CreateRenderPass)) + return reinterpret_cast(vkCreateRenderPass); + if (strcmp(pName, "vkDestroyRenderPass") == 0 && (!device || device_dispatch_table(device)->DestroyRenderPass)) + return reinterpret_cast(vkDestroyRenderPass); + if (strcmp(pName, "vkGetRenderAreaGranularity") == 0 && (!device || device_dispatch_table(device)->GetRenderAreaGranularity)) + return reinterpret_cast(vkGetRenderAreaGranularity); + if (strcmp(pName, "vkCmdSetViewport") == 0 && (!device || device_dispatch_table(device)->CmdSetViewport)) + return reinterpret_cast(vkCmdSetViewport); + if (strcmp(pName, "vkCmdSetScissor") == 0 && (!device || device_dispatch_table(device)->CmdSetScissor)) + return reinterpret_cast(vkCmdSetScissor); + if (strcmp(pName, "vkCmdSetLineWidth") == 0 && (!device || device_dispatch_table(device)->CmdSetLineWidth)) + return reinterpret_cast(vkCmdSetLineWidth); + if (strcmp(pName, "vkCmdSetDepthBias") == 0 && (!device || device_dispatch_table(device)->CmdSetDepthBias)) + return reinterpret_cast(vkCmdSetDepthBias); + if (strcmp(pName, "vkCmdSetBlendConstants") == 0 && (!device || device_dispatch_table(device)->CmdSetBlendConstants)) + return reinterpret_cast(vkCmdSetBlendConstants); + if (strcmp(pName, "vkCmdSetDepthBounds") == 0 && (!device || device_dispatch_table(device)->CmdSetDepthBounds)) + return reinterpret_cast(vkCmdSetDepthBounds); + if (strcmp(pName, "vkCmdSetStencilCompareMask") == 0 && (!device || device_dispatch_table(device)->CmdSetStencilCompareMask)) + return reinterpret_cast(vkCmdSetStencilCompareMask); + if (strcmp(pName, "vkCmdSetStencilWriteMask") == 0 && (!device || device_dispatch_table(device)->CmdSetStencilWriteMask)) + return reinterpret_cast(vkCmdSetStencilWriteMask); + if (strcmp(pName, "vkCmdSetStencilReference") == 0 && (!device || device_dispatch_table(device)->CmdSetStencilReference)) + return reinterpret_cast(vkCmdSetStencilReference); + if (strcmp(pName, "vkCmdBindIndexBuffer") == 0 && (!device || device_dispatch_table(device)->CmdBindIndexBuffer)) + return reinterpret_cast(vkCmdBindIndexBuffer); + if (strcmp(pName, "vkCmdBindVertexBuffers") == 0 && (!device || device_dispatch_table(device)->CmdBindVertexBuffers)) + return reinterpret_cast(vkCmdBindVertexBuffers); + if (strcmp(pName, "vkCmdDraw") == 0 && (!device || device_dispatch_table(device)->CmdDraw)) + return reinterpret_cast(vkCmdDraw); + if (strcmp(pName, "vkCmdDrawIndexed") == 0 && (!device || device_dispatch_table(device)->CmdDrawIndexed)) + return reinterpret_cast(vkCmdDrawIndexed); + if (strcmp(pName, "vkCmdDrawIndirect") == 0 && (!device || device_dispatch_table(device)->CmdDrawIndirect)) + return reinterpret_cast(vkCmdDrawIndirect); + if (strcmp(pName, "vkCmdDrawIndexedIndirect") == 0 && (!device || device_dispatch_table(device)->CmdDrawIndexedIndirect)) + return reinterpret_cast(vkCmdDrawIndexedIndirect); + if (strcmp(pName, "vkCmdBlitImage") == 0 && (!device || device_dispatch_table(device)->CmdBlitImage)) + return reinterpret_cast(vkCmdBlitImage); + if (strcmp(pName, "vkCmdClearDepthStencilImage") == 0 && (!device || device_dispatch_table(device)->CmdClearDepthStencilImage)) + return reinterpret_cast(vkCmdClearDepthStencilImage); + if (strcmp(pName, "vkCmdClearAttachments") == 0 && (!device || device_dispatch_table(device)->CmdClearAttachments)) + return reinterpret_cast(vkCmdClearAttachments); + if (strcmp(pName, "vkCmdResolveImage") == 0 && (!device || device_dispatch_table(device)->CmdResolveImage)) + return reinterpret_cast(vkCmdResolveImage); + if (strcmp(pName, "vkCmdBeginRenderPass") == 0 && (!device || device_dispatch_table(device)->CmdBeginRenderPass)) + return reinterpret_cast(vkCmdBeginRenderPass); + if (strcmp(pName, "vkCmdNextSubpass") == 0 && (!device || device_dispatch_table(device)->CmdNextSubpass)) + return reinterpret_cast(vkCmdNextSubpass); + if (strcmp(pName, "vkCmdEndRenderPass") == 0 && (!device || device_dispatch_table(device)->CmdEndRenderPass)) + return reinterpret_cast(vkCmdEndRenderPass); + if (strcmp(pName, "vkBindBufferMemory2") == 0 && (!device || device_dispatch_table(device)->BindBufferMemory2)) + return reinterpret_cast(vkBindBufferMemory2); + if (strcmp(pName, "vkBindImageMemory2") == 0 && (!device || device_dispatch_table(device)->BindImageMemory2)) + return reinterpret_cast(vkBindImageMemory2); + if (strcmp(pName, "vkGetDeviceGroupPeerMemoryFeatures") == 0 && (!device || device_dispatch_table(device)->GetDeviceGroupPeerMemoryFeatures)) + return reinterpret_cast(vkGetDeviceGroupPeerMemoryFeatures); + if (strcmp(pName, "vkCmdSetDeviceMask") == 0 && (!device || device_dispatch_table(device)->CmdSetDeviceMask)) + return reinterpret_cast(vkCmdSetDeviceMask); + if (strcmp(pName, "vkGetImageMemoryRequirements2") == 0 && (!device || device_dispatch_table(device)->GetImageMemoryRequirements2)) + return reinterpret_cast(vkGetImageMemoryRequirements2); + if (strcmp(pName, "vkGetBufferMemoryRequirements2") == 0 && (!device || device_dispatch_table(device)->GetBufferMemoryRequirements2)) + return reinterpret_cast(vkGetBufferMemoryRequirements2); + if (strcmp(pName, "vkGetImageSparseMemoryRequirements2") == 0 && (!device || device_dispatch_table(device)->GetImageSparseMemoryRequirements2)) + return reinterpret_cast(vkGetImageSparseMemoryRequirements2); + if (strcmp(pName, "vkTrimCommandPool") == 0 && (!device || device_dispatch_table(device)->TrimCommandPool)) + return reinterpret_cast(vkTrimCommandPool); + if (strcmp(pName, "vkGetDeviceQueue2") == 0 && (!device || device_dispatch_table(device)->GetDeviceQueue2)) + return reinterpret_cast(vkGetDeviceQueue2); + if (strcmp(pName, "vkCmdDispatchBase") == 0 && (!device || device_dispatch_table(device)->CmdDispatchBase)) + return reinterpret_cast(vkCmdDispatchBase); + if (strcmp(pName, "vkCreateDescriptorUpdateTemplate") == 0 && (!device || device_dispatch_table(device)->CreateDescriptorUpdateTemplate)) + return reinterpret_cast(vkCreateDescriptorUpdateTemplate); + if (strcmp(pName, "vkDestroyDescriptorUpdateTemplate") == 0 && (!device || device_dispatch_table(device)->DestroyDescriptorUpdateTemplate)) + return reinterpret_cast(vkDestroyDescriptorUpdateTemplate); + if (strcmp(pName, "vkUpdateDescriptorSetWithTemplate") == 0 && (!device || device_dispatch_table(device)->UpdateDescriptorSetWithTemplate)) + return reinterpret_cast(vkUpdateDescriptorSetWithTemplate); + if (strcmp(pName, "vkGetDescriptorSetLayoutSupport") == 0 && (!device || device_dispatch_table(device)->GetDescriptorSetLayoutSupport)) + return reinterpret_cast(vkGetDescriptorSetLayoutSupport); + if (strcmp(pName, "vkCreateSamplerYcbcrConversion") == 0 && (!device || device_dispatch_table(device)->CreateSamplerYcbcrConversion)) + return reinterpret_cast(vkCreateSamplerYcbcrConversion); + if (strcmp(pName, "vkDestroySamplerYcbcrConversion") == 0 && (!device || device_dispatch_table(device)->DestroySamplerYcbcrConversion)) + return reinterpret_cast(vkDestroySamplerYcbcrConversion); + if (strcmp(pName, "vkResetQueryPool") == 0 && (!device || device_dispatch_table(device)->ResetQueryPool)) + return reinterpret_cast(vkResetQueryPool); + if (strcmp(pName, "vkGetSemaphoreCounterValue") == 0 && (!device || device_dispatch_table(device)->GetSemaphoreCounterValue)) + return reinterpret_cast(vkGetSemaphoreCounterValue); + if (strcmp(pName, "vkWaitSemaphores") == 0 && (!device || device_dispatch_table(device)->WaitSemaphores)) + return reinterpret_cast(vkWaitSemaphores); + if (strcmp(pName, "vkSignalSemaphore") == 0 && (!device || device_dispatch_table(device)->SignalSemaphore)) + return reinterpret_cast(vkSignalSemaphore); + if (strcmp(pName, "vkGetBufferDeviceAddress") == 0 && (!device || device_dispatch_table(device)->GetBufferDeviceAddress)) + return reinterpret_cast(vkGetBufferDeviceAddress); + if (strcmp(pName, "vkGetBufferOpaqueCaptureAddress") == 0 && (!device || device_dispatch_table(device)->GetBufferOpaqueCaptureAddress)) + return reinterpret_cast(vkGetBufferOpaqueCaptureAddress); + if (strcmp(pName, "vkGetDeviceMemoryOpaqueCaptureAddress") == 0 && (!device || device_dispatch_table(device)->GetDeviceMemoryOpaqueCaptureAddress)) + return reinterpret_cast(vkGetDeviceMemoryOpaqueCaptureAddress); + if (strcmp(pName, "vkCmdDrawIndirectCount") == 0 && (!device || device_dispatch_table(device)->CmdDrawIndirectCount)) + return reinterpret_cast(vkCmdDrawIndirectCount); + if (strcmp(pName, "vkCmdDrawIndexedIndirectCount") == 0 && (!device || device_dispatch_table(device)->CmdDrawIndexedIndirectCount)) + return reinterpret_cast(vkCmdDrawIndexedIndirectCount); + if (strcmp(pName, "vkCreateRenderPass2") == 0 && (!device || device_dispatch_table(device)->CreateRenderPass2)) + return reinterpret_cast(vkCreateRenderPass2); + if (strcmp(pName, "vkCmdBeginRenderPass2") == 0 && (!device || device_dispatch_table(device)->CmdBeginRenderPass2)) + return reinterpret_cast(vkCmdBeginRenderPass2); + if (strcmp(pName, "vkCmdNextSubpass2") == 0 && (!device || device_dispatch_table(device)->CmdNextSubpass2)) + return reinterpret_cast(vkCmdNextSubpass2); + if (strcmp(pName, "vkCmdEndRenderPass2") == 0 && (!device || device_dispatch_table(device)->CmdEndRenderPass2)) + return reinterpret_cast(vkCmdEndRenderPass2); + if (strcmp(pName, "vkCreatePrivateDataSlot") == 0 && (!device || device_dispatch_table(device)->CreatePrivateDataSlot)) + return reinterpret_cast(vkCreatePrivateDataSlot); + if (strcmp(pName, "vkDestroyPrivateDataSlot") == 0 && (!device || device_dispatch_table(device)->DestroyPrivateDataSlot)) + return reinterpret_cast(vkDestroyPrivateDataSlot); + if (strcmp(pName, "vkSetPrivateData") == 0 && (!device || device_dispatch_table(device)->SetPrivateData)) + return reinterpret_cast(vkSetPrivateData); + if (strcmp(pName, "vkGetPrivateData") == 0 && (!device || device_dispatch_table(device)->GetPrivateData)) + return reinterpret_cast(vkGetPrivateData); + if (strcmp(pName, "vkCmdPipelineBarrier2") == 0 && (!device || device_dispatch_table(device)->CmdPipelineBarrier2)) + return reinterpret_cast(vkCmdPipelineBarrier2); + if (strcmp(pName, "vkCmdWriteTimestamp2") == 0 && (!device || device_dispatch_table(device)->CmdWriteTimestamp2)) + return reinterpret_cast(vkCmdWriteTimestamp2); + if (strcmp(pName, "vkQueueSubmit2") == 0 && (!device || device_dispatch_table(device)->QueueSubmit2)) + return reinterpret_cast(vkQueueSubmit2); + if (strcmp(pName, "vkCmdCopyBuffer2") == 0 && (!device || device_dispatch_table(device)->CmdCopyBuffer2)) + return reinterpret_cast(vkCmdCopyBuffer2); + if (strcmp(pName, "vkCmdCopyImage2") == 0 && (!device || device_dispatch_table(device)->CmdCopyImage2)) + return reinterpret_cast(vkCmdCopyImage2); + if (strcmp(pName, "vkCmdCopyBufferToImage2") == 0 && (!device || device_dispatch_table(device)->CmdCopyBufferToImage2)) + return reinterpret_cast(vkCmdCopyBufferToImage2); + if (strcmp(pName, "vkCmdCopyImageToBuffer2") == 0 && (!device || device_dispatch_table(device)->CmdCopyImageToBuffer2)) + return reinterpret_cast(vkCmdCopyImageToBuffer2); + if (strcmp(pName, "vkGetDeviceBufferMemoryRequirements") == 0 && (!device || device_dispatch_table(device)->GetDeviceBufferMemoryRequirements)) + return reinterpret_cast(vkGetDeviceBufferMemoryRequirements); + if (strcmp(pName, "vkGetDeviceImageMemoryRequirements") == 0 && (!device || device_dispatch_table(device)->GetDeviceImageMemoryRequirements)) + return reinterpret_cast(vkGetDeviceImageMemoryRequirements); + if (strcmp(pName, "vkGetDeviceImageSparseMemoryRequirements") == 0 && (!device || device_dispatch_table(device)->GetDeviceImageSparseMemoryRequirements)) + return reinterpret_cast(vkGetDeviceImageSparseMemoryRequirements); + if (strcmp(pName, "vkCmdSetEvent2") == 0 && (!device || device_dispatch_table(device)->CmdSetEvent2)) + return reinterpret_cast(vkCmdSetEvent2); + if (strcmp(pName, "vkCmdResetEvent2") == 0 && (!device || device_dispatch_table(device)->CmdResetEvent2)) + return reinterpret_cast(vkCmdResetEvent2); + if (strcmp(pName, "vkCmdWaitEvents2") == 0 && (!device || device_dispatch_table(device)->CmdWaitEvents2)) + return reinterpret_cast(vkCmdWaitEvents2); + if (strcmp(pName, "vkCmdBlitImage2") == 0 && (!device || device_dispatch_table(device)->CmdBlitImage2)) + return reinterpret_cast(vkCmdBlitImage2); + if (strcmp(pName, "vkCmdResolveImage2") == 0 && (!device || device_dispatch_table(device)->CmdResolveImage2)) + return reinterpret_cast(vkCmdResolveImage2); + if (strcmp(pName, "vkCmdBeginRendering") == 0 && (!device || device_dispatch_table(device)->CmdBeginRendering)) + return reinterpret_cast(vkCmdBeginRendering); + if (strcmp(pName, "vkCmdEndRendering") == 0 && (!device || device_dispatch_table(device)->CmdEndRendering)) + return reinterpret_cast(vkCmdEndRendering); + if (strcmp(pName, "vkCmdSetCullMode") == 0 && (!device || device_dispatch_table(device)->CmdSetCullMode)) + return reinterpret_cast(vkCmdSetCullMode); + if (strcmp(pName, "vkCmdSetFrontFace") == 0 && (!device || device_dispatch_table(device)->CmdSetFrontFace)) + return reinterpret_cast(vkCmdSetFrontFace); + if (strcmp(pName, "vkCmdSetPrimitiveTopology") == 0 && (!device || device_dispatch_table(device)->CmdSetPrimitiveTopology)) + return reinterpret_cast(vkCmdSetPrimitiveTopology); + if (strcmp(pName, "vkCmdSetViewportWithCount") == 0 && (!device || device_dispatch_table(device)->CmdSetViewportWithCount)) + return reinterpret_cast(vkCmdSetViewportWithCount); + if (strcmp(pName, "vkCmdSetScissorWithCount") == 0 && (!device || device_dispatch_table(device)->CmdSetScissorWithCount)) + return reinterpret_cast(vkCmdSetScissorWithCount); + if (strcmp(pName, "vkCmdBindVertexBuffers2") == 0 && (!device || device_dispatch_table(device)->CmdBindVertexBuffers2)) + return reinterpret_cast(vkCmdBindVertexBuffers2); + if (strcmp(pName, "vkCmdSetDepthTestEnable") == 0 && (!device || device_dispatch_table(device)->CmdSetDepthTestEnable)) + return reinterpret_cast(vkCmdSetDepthTestEnable); + if (strcmp(pName, "vkCmdSetDepthWriteEnable") == 0 && (!device || device_dispatch_table(device)->CmdSetDepthWriteEnable)) + return reinterpret_cast(vkCmdSetDepthWriteEnable); + if (strcmp(pName, "vkCmdSetDepthCompareOp") == 0 && (!device || device_dispatch_table(device)->CmdSetDepthCompareOp)) + return reinterpret_cast(vkCmdSetDepthCompareOp); + if (strcmp(pName, "vkCmdSetDepthBoundsTestEnable") == 0 && (!device || device_dispatch_table(device)->CmdSetDepthBoundsTestEnable)) + return reinterpret_cast(vkCmdSetDepthBoundsTestEnable); + if (strcmp(pName, "vkCmdSetStencilTestEnable") == 0 && (!device || device_dispatch_table(device)->CmdSetStencilTestEnable)) + return reinterpret_cast(vkCmdSetStencilTestEnable); + if (strcmp(pName, "vkCmdSetStencilOp") == 0 && (!device || device_dispatch_table(device)->CmdSetStencilOp)) + return reinterpret_cast(vkCmdSetStencilOp); + if (strcmp(pName, "vkCmdSetRasterizerDiscardEnable") == 0 && (!device || device_dispatch_table(device)->CmdSetRasterizerDiscardEnable)) + return reinterpret_cast(vkCmdSetRasterizerDiscardEnable); + if (strcmp(pName, "vkCmdSetDepthBiasEnable") == 0 && (!device || device_dispatch_table(device)->CmdSetDepthBiasEnable)) + return reinterpret_cast(vkCmdSetDepthBiasEnable); + if (strcmp(pName, "vkCmdSetPrimitiveRestartEnable") == 0 && (!device || device_dispatch_table(device)->CmdSetPrimitiveRestartEnable)) + return reinterpret_cast(vkCmdSetPrimitiveRestartEnable); + if (strcmp(pName, "vkMapMemory2") == 0 && (!device || device_dispatch_table(device)->MapMemory2)) + return reinterpret_cast(vkMapMemory2); + if (strcmp(pName, "vkUnmapMemory2") == 0 && (!device || device_dispatch_table(device)->UnmapMemory2)) + return reinterpret_cast(vkUnmapMemory2); + if (strcmp(pName, "vkGetDeviceImageSubresourceLayout") == 0 && (!device || device_dispatch_table(device)->GetDeviceImageSubresourceLayout)) + return reinterpret_cast(vkGetDeviceImageSubresourceLayout); + if (strcmp(pName, "vkGetImageSubresourceLayout2") == 0 && (!device || device_dispatch_table(device)->GetImageSubresourceLayout2)) + return reinterpret_cast(vkGetImageSubresourceLayout2); + if (strcmp(pName, "vkCopyMemoryToImage") == 0 && (!device || device_dispatch_table(device)->CopyMemoryToImage)) + return reinterpret_cast(vkCopyMemoryToImage); + if (strcmp(pName, "vkCopyImageToMemory") == 0 && (!device || device_dispatch_table(device)->CopyImageToMemory)) + return reinterpret_cast(vkCopyImageToMemory); + if (strcmp(pName, "vkCopyImageToImage") == 0 && (!device || device_dispatch_table(device)->CopyImageToImage)) + return reinterpret_cast(vkCopyImageToImage); + if (strcmp(pName, "vkTransitionImageLayout") == 0 && (!device || device_dispatch_table(device)->TransitionImageLayout)) + return reinterpret_cast(vkTransitionImageLayout); + if (strcmp(pName, "vkCmdPushDescriptorSet") == 0 && (!device || device_dispatch_table(device)->CmdPushDescriptorSet)) + return reinterpret_cast(vkCmdPushDescriptorSet); + if (strcmp(pName, "vkCmdPushDescriptorSetWithTemplate") == 0 && (!device || device_dispatch_table(device)->CmdPushDescriptorSetWithTemplate)) + return reinterpret_cast(vkCmdPushDescriptorSetWithTemplate); + if (strcmp(pName, "vkCmdBindDescriptorSets2") == 0 && (!device || device_dispatch_table(device)->CmdBindDescriptorSets2)) + return reinterpret_cast(vkCmdBindDescriptorSets2); + if (strcmp(pName, "vkCmdPushConstants2") == 0 && (!device || device_dispatch_table(device)->CmdPushConstants2)) + return reinterpret_cast(vkCmdPushConstants2); + if (strcmp(pName, "vkCmdPushDescriptorSet2") == 0 && (!device || device_dispatch_table(device)->CmdPushDescriptorSet2)) + return reinterpret_cast(vkCmdPushDescriptorSet2); + if (strcmp(pName, "vkCmdPushDescriptorSetWithTemplate2") == 0 && (!device || device_dispatch_table(device)->CmdPushDescriptorSetWithTemplate2)) + return reinterpret_cast(vkCmdPushDescriptorSetWithTemplate2); + if (strcmp(pName, "vkCmdSetLineStipple") == 0 && (!device || device_dispatch_table(device)->CmdSetLineStipple)) + return reinterpret_cast(vkCmdSetLineStipple); + if (strcmp(pName, "vkCmdBindIndexBuffer2") == 0 && (!device || device_dispatch_table(device)->CmdBindIndexBuffer2)) + return reinterpret_cast(vkCmdBindIndexBuffer2); + if (strcmp(pName, "vkGetRenderingAreaGranularity") == 0 && (!device || device_dispatch_table(device)->GetRenderingAreaGranularity)) + return reinterpret_cast(vkGetRenderingAreaGranularity); + if (strcmp(pName, "vkCmdSetRenderingAttachmentLocations") == 0 && (!device || device_dispatch_table(device)->CmdSetRenderingAttachmentLocations)) + return reinterpret_cast(vkCmdSetRenderingAttachmentLocations); + if (strcmp(pName, "vkCmdSetRenderingInputAttachmentIndices") == 0 && (!device || device_dispatch_table(device)->CmdSetRenderingInputAttachmentIndices)) + return reinterpret_cast(vkCmdSetRenderingInputAttachmentIndices); + if (strcmp(pName, "vkCreateSwapchainKHR") == 0 && (!device || device_dispatch_table(device)->CreateSwapchainKHR)) + return reinterpret_cast(vkCreateSwapchainKHR); + if (strcmp(pName, "vkDestroySwapchainKHR") == 0 && (!device || device_dispatch_table(device)->DestroySwapchainKHR)) + return reinterpret_cast(vkDestroySwapchainKHR); + if (strcmp(pName, "vkGetSwapchainImagesKHR") == 0 && (!device || device_dispatch_table(device)->GetSwapchainImagesKHR)) + return reinterpret_cast(vkGetSwapchainImagesKHR); + if (strcmp(pName, "vkAcquireNextImageKHR") == 0 && (!device || device_dispatch_table(device)->AcquireNextImageKHR)) + return reinterpret_cast(vkAcquireNextImageKHR); + if (strcmp(pName, "vkQueuePresentKHR") == 0 && (!device || device_dispatch_table(device)->QueuePresentKHR)) + return reinterpret_cast(vkQueuePresentKHR); + if (strcmp(pName, "vkGetDeviceGroupPresentCapabilitiesKHR") == 0 && (!device || device_dispatch_table(device)->GetDeviceGroupPresentCapabilitiesKHR)) + return reinterpret_cast(vkGetDeviceGroupPresentCapabilitiesKHR); + if (strcmp(pName, "vkGetDeviceGroupSurfacePresentModesKHR") == 0 && (!device || device_dispatch_table(device)->GetDeviceGroupSurfacePresentModesKHR)) + return reinterpret_cast(vkGetDeviceGroupSurfacePresentModesKHR); + if (strcmp(pName, "vkAcquireNextImage2KHR") == 0 && (!device || device_dispatch_table(device)->AcquireNextImage2KHR)) + return reinterpret_cast(vkAcquireNextImage2KHR); + if (strcmp(pName, "vkCreateSharedSwapchainsKHR") == 0 && (!device || device_dispatch_table(device)->CreateSharedSwapchainsKHR)) + return reinterpret_cast(vkCreateSharedSwapchainsKHR); + if (strcmp(pName, "vkCreateVideoSessionKHR") == 0 && (!device || device_dispatch_table(device)->CreateVideoSessionKHR)) + return reinterpret_cast(vkCreateVideoSessionKHR); + if (strcmp(pName, "vkDestroyVideoSessionKHR") == 0 && (!device || device_dispatch_table(device)->DestroyVideoSessionKHR)) + return reinterpret_cast(vkDestroyVideoSessionKHR); + if (strcmp(pName, "vkGetVideoSessionMemoryRequirementsKHR") == 0 && (!device || device_dispatch_table(device)->GetVideoSessionMemoryRequirementsKHR)) + return reinterpret_cast(vkGetVideoSessionMemoryRequirementsKHR); + if (strcmp(pName, "vkBindVideoSessionMemoryKHR") == 0 && (!device || device_dispatch_table(device)->BindVideoSessionMemoryKHR)) + return reinterpret_cast(vkBindVideoSessionMemoryKHR); + if (strcmp(pName, "vkCreateVideoSessionParametersKHR") == 0 && (!device || device_dispatch_table(device)->CreateVideoSessionParametersKHR)) + return reinterpret_cast(vkCreateVideoSessionParametersKHR); + if (strcmp(pName, "vkUpdateVideoSessionParametersKHR") == 0 && (!device || device_dispatch_table(device)->UpdateVideoSessionParametersKHR)) + return reinterpret_cast(vkUpdateVideoSessionParametersKHR); + if (strcmp(pName, "vkDestroyVideoSessionParametersKHR") == 0 && (!device || device_dispatch_table(device)->DestroyVideoSessionParametersKHR)) + return reinterpret_cast(vkDestroyVideoSessionParametersKHR); + if (strcmp(pName, "vkCmdBeginVideoCodingKHR") == 0 && (!device || device_dispatch_table(device)->CmdBeginVideoCodingKHR)) + return reinterpret_cast(vkCmdBeginVideoCodingKHR); + if (strcmp(pName, "vkCmdEndVideoCodingKHR") == 0 && (!device || device_dispatch_table(device)->CmdEndVideoCodingKHR)) + return reinterpret_cast(vkCmdEndVideoCodingKHR); + if (strcmp(pName, "vkCmdControlVideoCodingKHR") == 0 && (!device || device_dispatch_table(device)->CmdControlVideoCodingKHR)) + return reinterpret_cast(vkCmdControlVideoCodingKHR); + if (strcmp(pName, "vkCmdDecodeVideoKHR") == 0 && (!device || device_dispatch_table(device)->CmdDecodeVideoKHR)) + return reinterpret_cast(vkCmdDecodeVideoKHR); + if (strcmp(pName, "vkCmdBeginRenderingKHR") == 0 && (!device || device_dispatch_table(device)->CmdBeginRenderingKHR)) + return reinterpret_cast(vkCmdBeginRenderingKHR); + if (strcmp(pName, "vkCmdEndRenderingKHR") == 0 && (!device || device_dispatch_table(device)->CmdEndRenderingKHR)) + return reinterpret_cast(vkCmdEndRenderingKHR); + if (strcmp(pName, "vkGetDeviceGroupPeerMemoryFeaturesKHR") == 0 && (!device || device_dispatch_table(device)->GetDeviceGroupPeerMemoryFeaturesKHR)) + return reinterpret_cast(vkGetDeviceGroupPeerMemoryFeaturesKHR); + if (strcmp(pName, "vkCmdSetDeviceMaskKHR") == 0 && (!device || device_dispatch_table(device)->CmdSetDeviceMaskKHR)) + return reinterpret_cast(vkCmdSetDeviceMaskKHR); + if (strcmp(pName, "vkCmdDispatchBaseKHR") == 0 && (!device || device_dispatch_table(device)->CmdDispatchBaseKHR)) + return reinterpret_cast(vkCmdDispatchBaseKHR); + if (strcmp(pName, "vkTrimCommandPoolKHR") == 0 && (!device || device_dispatch_table(device)->TrimCommandPoolKHR)) + return reinterpret_cast(vkTrimCommandPoolKHR); +#if defined(VK_USE_PLATFORM_WIN32_KHR) + if (strcmp(pName, "vkGetMemoryWin32HandleKHR") == 0 && (!device || device_dispatch_table(device)->GetMemoryWin32HandleKHR)) + return reinterpret_cast(vkGetMemoryWin32HandleKHR); + if (strcmp(pName, "vkGetMemoryWin32HandlePropertiesKHR") == 0 && (!device || device_dispatch_table(device)->GetMemoryWin32HandlePropertiesKHR)) + return reinterpret_cast(vkGetMemoryWin32HandlePropertiesKHR); +#endif // VK_USE_PLATFORM_WIN32_KHR + if (strcmp(pName, "vkGetMemoryFdKHR") == 0 && (!device || device_dispatch_table(device)->GetMemoryFdKHR)) + return reinterpret_cast(vkGetMemoryFdKHR); + if (strcmp(pName, "vkGetMemoryFdPropertiesKHR") == 0 && (!device || device_dispatch_table(device)->GetMemoryFdPropertiesKHR)) + return reinterpret_cast(vkGetMemoryFdPropertiesKHR); +#if defined(VK_USE_PLATFORM_WIN32_KHR) + if (strcmp(pName, "vkImportSemaphoreWin32HandleKHR") == 0 && (!device || device_dispatch_table(device)->ImportSemaphoreWin32HandleKHR)) + return reinterpret_cast(vkImportSemaphoreWin32HandleKHR); + if (strcmp(pName, "vkGetSemaphoreWin32HandleKHR") == 0 && (!device || device_dispatch_table(device)->GetSemaphoreWin32HandleKHR)) + return reinterpret_cast(vkGetSemaphoreWin32HandleKHR); +#endif // VK_USE_PLATFORM_WIN32_KHR + if (strcmp(pName, "vkImportSemaphoreFdKHR") == 0 && (!device || device_dispatch_table(device)->ImportSemaphoreFdKHR)) + return reinterpret_cast(vkImportSemaphoreFdKHR); + if (strcmp(pName, "vkGetSemaphoreFdKHR") == 0 && (!device || device_dispatch_table(device)->GetSemaphoreFdKHR)) + return reinterpret_cast(vkGetSemaphoreFdKHR); + if (strcmp(pName, "vkCmdPushDescriptorSetKHR") == 0 && (!device || device_dispatch_table(device)->CmdPushDescriptorSetKHR)) + return reinterpret_cast(vkCmdPushDescriptorSetKHR); + if (strcmp(pName, "vkCmdPushDescriptorSetWithTemplateKHR") == 0 && (!device || device_dispatch_table(device)->CmdPushDescriptorSetWithTemplateKHR)) + return reinterpret_cast(vkCmdPushDescriptorSetWithTemplateKHR); + if (strcmp(pName, "vkCreateDescriptorUpdateTemplateKHR") == 0 && (!device || device_dispatch_table(device)->CreateDescriptorUpdateTemplateKHR)) + return reinterpret_cast(vkCreateDescriptorUpdateTemplateKHR); + if (strcmp(pName, "vkDestroyDescriptorUpdateTemplateKHR") == 0 && (!device || device_dispatch_table(device)->DestroyDescriptorUpdateTemplateKHR)) + return reinterpret_cast(vkDestroyDescriptorUpdateTemplateKHR); + if (strcmp(pName, "vkUpdateDescriptorSetWithTemplateKHR") == 0 && (!device || device_dispatch_table(device)->UpdateDescriptorSetWithTemplateKHR)) + return reinterpret_cast(vkUpdateDescriptorSetWithTemplateKHR); + if (strcmp(pName, "vkCreateRenderPass2KHR") == 0 && (!device || device_dispatch_table(device)->CreateRenderPass2KHR)) + return reinterpret_cast(vkCreateRenderPass2KHR); + if (strcmp(pName, "vkCmdBeginRenderPass2KHR") == 0 && (!device || device_dispatch_table(device)->CmdBeginRenderPass2KHR)) + return reinterpret_cast(vkCmdBeginRenderPass2KHR); + if (strcmp(pName, "vkCmdNextSubpass2KHR") == 0 && (!device || device_dispatch_table(device)->CmdNextSubpass2KHR)) + return reinterpret_cast(vkCmdNextSubpass2KHR); + if (strcmp(pName, "vkCmdEndRenderPass2KHR") == 0 && (!device || device_dispatch_table(device)->CmdEndRenderPass2KHR)) + return reinterpret_cast(vkCmdEndRenderPass2KHR); + if (strcmp(pName, "vkGetSwapchainStatusKHR") == 0 && (!device || device_dispatch_table(device)->GetSwapchainStatusKHR)) + return reinterpret_cast(vkGetSwapchainStatusKHR); +#if defined(VK_USE_PLATFORM_WIN32_KHR) + if (strcmp(pName, "vkImportFenceWin32HandleKHR") == 0 && (!device || device_dispatch_table(device)->ImportFenceWin32HandleKHR)) + return reinterpret_cast(vkImportFenceWin32HandleKHR); + if (strcmp(pName, "vkGetFenceWin32HandleKHR") == 0 && (!device || device_dispatch_table(device)->GetFenceWin32HandleKHR)) + return reinterpret_cast(vkGetFenceWin32HandleKHR); +#endif // VK_USE_PLATFORM_WIN32_KHR + if (strcmp(pName, "vkImportFenceFdKHR") == 0 && (!device || device_dispatch_table(device)->ImportFenceFdKHR)) + return reinterpret_cast(vkImportFenceFdKHR); + if (strcmp(pName, "vkGetFenceFdKHR") == 0 && (!device || device_dispatch_table(device)->GetFenceFdKHR)) + return reinterpret_cast(vkGetFenceFdKHR); + if (strcmp(pName, "vkAcquireProfilingLockKHR") == 0 && (!device || device_dispatch_table(device)->AcquireProfilingLockKHR)) + return reinterpret_cast(vkAcquireProfilingLockKHR); + if (strcmp(pName, "vkReleaseProfilingLockKHR") == 0 && (!device || device_dispatch_table(device)->ReleaseProfilingLockKHR)) + return reinterpret_cast(vkReleaseProfilingLockKHR); + if (strcmp(pName, "vkGetImageMemoryRequirements2KHR") == 0 && (!device || device_dispatch_table(device)->GetImageMemoryRequirements2KHR)) + return reinterpret_cast(vkGetImageMemoryRequirements2KHR); + if (strcmp(pName, "vkGetBufferMemoryRequirements2KHR") == 0 && (!device || device_dispatch_table(device)->GetBufferMemoryRequirements2KHR)) + return reinterpret_cast(vkGetBufferMemoryRequirements2KHR); + if (strcmp(pName, "vkGetImageSparseMemoryRequirements2KHR") == 0 && (!device || device_dispatch_table(device)->GetImageSparseMemoryRequirements2KHR)) + return reinterpret_cast(vkGetImageSparseMemoryRequirements2KHR); + if (strcmp(pName, "vkCreateSamplerYcbcrConversionKHR") == 0 && (!device || device_dispatch_table(device)->CreateSamplerYcbcrConversionKHR)) + return reinterpret_cast(vkCreateSamplerYcbcrConversionKHR); + if (strcmp(pName, "vkDestroySamplerYcbcrConversionKHR") == 0 && (!device || device_dispatch_table(device)->DestroySamplerYcbcrConversionKHR)) + return reinterpret_cast(vkDestroySamplerYcbcrConversionKHR); + if (strcmp(pName, "vkBindBufferMemory2KHR") == 0 && (!device || device_dispatch_table(device)->BindBufferMemory2KHR)) + return reinterpret_cast(vkBindBufferMemory2KHR); + if (strcmp(pName, "vkBindImageMemory2KHR") == 0 && (!device || device_dispatch_table(device)->BindImageMemory2KHR)) + return reinterpret_cast(vkBindImageMemory2KHR); + if (strcmp(pName, "vkGetDescriptorSetLayoutSupportKHR") == 0 && (!device || device_dispatch_table(device)->GetDescriptorSetLayoutSupportKHR)) + return reinterpret_cast(vkGetDescriptorSetLayoutSupportKHR); + if (strcmp(pName, "vkCmdDrawIndirectCountKHR") == 0 && (!device || device_dispatch_table(device)->CmdDrawIndirectCountKHR)) + return reinterpret_cast(vkCmdDrawIndirectCountKHR); + if (strcmp(pName, "vkCmdDrawIndexedIndirectCountKHR") == 0 && (!device || device_dispatch_table(device)->CmdDrawIndexedIndirectCountKHR)) + return reinterpret_cast(vkCmdDrawIndexedIndirectCountKHR); + if (strcmp(pName, "vkGetSemaphoreCounterValueKHR") == 0 && (!device || device_dispatch_table(device)->GetSemaphoreCounterValueKHR)) + return reinterpret_cast(vkGetSemaphoreCounterValueKHR); + if (strcmp(pName, "vkWaitSemaphoresKHR") == 0 && (!device || device_dispatch_table(device)->WaitSemaphoresKHR)) + return reinterpret_cast(vkWaitSemaphoresKHR); + if (strcmp(pName, "vkSignalSemaphoreKHR") == 0 && (!device || device_dispatch_table(device)->SignalSemaphoreKHR)) + return reinterpret_cast(vkSignalSemaphoreKHR); + if (strcmp(pName, "vkCmdSetFragmentShadingRateKHR") == 0 && (!device || device_dispatch_table(device)->CmdSetFragmentShadingRateKHR)) + return reinterpret_cast(vkCmdSetFragmentShadingRateKHR); + if (strcmp(pName, "vkCmdSetRenderingAttachmentLocationsKHR") == 0 && (!device || device_dispatch_table(device)->CmdSetRenderingAttachmentLocationsKHR)) + return reinterpret_cast(vkCmdSetRenderingAttachmentLocationsKHR); + if (strcmp(pName, "vkCmdSetRenderingInputAttachmentIndicesKHR") == 0 && (!device || device_dispatch_table(device)->CmdSetRenderingInputAttachmentIndicesKHR)) + return reinterpret_cast(vkCmdSetRenderingInputAttachmentIndicesKHR); + if (strcmp(pName, "vkWaitForPresentKHR") == 0 && (!device || device_dispatch_table(device)->WaitForPresentKHR)) + return reinterpret_cast(vkWaitForPresentKHR); + if (strcmp(pName, "vkGetBufferDeviceAddressKHR") == 0 && (!device || device_dispatch_table(device)->GetBufferDeviceAddressKHR)) + return reinterpret_cast(vkGetBufferDeviceAddressKHR); + if (strcmp(pName, "vkGetBufferOpaqueCaptureAddressKHR") == 0 && (!device || device_dispatch_table(device)->GetBufferOpaqueCaptureAddressKHR)) + return reinterpret_cast(vkGetBufferOpaqueCaptureAddressKHR); + if (strcmp(pName, "vkGetDeviceMemoryOpaqueCaptureAddressKHR") == 0 && (!device || device_dispatch_table(device)->GetDeviceMemoryOpaqueCaptureAddressKHR)) + return reinterpret_cast(vkGetDeviceMemoryOpaqueCaptureAddressKHR); + if (strcmp(pName, "vkCreateDeferredOperationKHR") == 0 && (!device || device_dispatch_table(device)->CreateDeferredOperationKHR)) + return reinterpret_cast(vkCreateDeferredOperationKHR); + if (strcmp(pName, "vkDestroyDeferredOperationKHR") == 0 && (!device || device_dispatch_table(device)->DestroyDeferredOperationKHR)) + return reinterpret_cast(vkDestroyDeferredOperationKHR); + if (strcmp(pName, "vkGetDeferredOperationMaxConcurrencyKHR") == 0 && (!device || device_dispatch_table(device)->GetDeferredOperationMaxConcurrencyKHR)) + return reinterpret_cast(vkGetDeferredOperationMaxConcurrencyKHR); + if (strcmp(pName, "vkGetDeferredOperationResultKHR") == 0 && (!device || device_dispatch_table(device)->GetDeferredOperationResultKHR)) + return reinterpret_cast(vkGetDeferredOperationResultKHR); + if (strcmp(pName, "vkDeferredOperationJoinKHR") == 0 && (!device || device_dispatch_table(device)->DeferredOperationJoinKHR)) + return reinterpret_cast(vkDeferredOperationJoinKHR); + if (strcmp(pName, "vkGetPipelineExecutablePropertiesKHR") == 0 && (!device || device_dispatch_table(device)->GetPipelineExecutablePropertiesKHR)) + return reinterpret_cast(vkGetPipelineExecutablePropertiesKHR); + if (strcmp(pName, "vkGetPipelineExecutableStatisticsKHR") == 0 && (!device || device_dispatch_table(device)->GetPipelineExecutableStatisticsKHR)) + return reinterpret_cast(vkGetPipelineExecutableStatisticsKHR); + if (strcmp(pName, "vkGetPipelineExecutableInternalRepresentationsKHR") == 0 && (!device || device_dispatch_table(device)->GetPipelineExecutableInternalRepresentationsKHR)) + return reinterpret_cast(vkGetPipelineExecutableInternalRepresentationsKHR); + if (strcmp(pName, "vkMapMemory2KHR") == 0 && (!device || device_dispatch_table(device)->MapMemory2KHR)) + return reinterpret_cast(vkMapMemory2KHR); + if (strcmp(pName, "vkUnmapMemory2KHR") == 0 && (!device || device_dispatch_table(device)->UnmapMemory2KHR)) + return reinterpret_cast(vkUnmapMemory2KHR); + if (strcmp(pName, "vkGetEncodedVideoSessionParametersKHR") == 0 && (!device || device_dispatch_table(device)->GetEncodedVideoSessionParametersKHR)) + return reinterpret_cast(vkGetEncodedVideoSessionParametersKHR); + if (strcmp(pName, "vkCmdEncodeVideoKHR") == 0 && (!device || device_dispatch_table(device)->CmdEncodeVideoKHR)) + return reinterpret_cast(vkCmdEncodeVideoKHR); + if (strcmp(pName, "vkCmdSetEvent2KHR") == 0 && (!device || device_dispatch_table(device)->CmdSetEvent2KHR)) + return reinterpret_cast(vkCmdSetEvent2KHR); + if (strcmp(pName, "vkCmdResetEvent2KHR") == 0 && (!device || device_dispatch_table(device)->CmdResetEvent2KHR)) + return reinterpret_cast(vkCmdResetEvent2KHR); + if (strcmp(pName, "vkCmdWaitEvents2KHR") == 0 && (!device || device_dispatch_table(device)->CmdWaitEvents2KHR)) + return reinterpret_cast(vkCmdWaitEvents2KHR); + if (strcmp(pName, "vkCmdPipelineBarrier2KHR") == 0 && (!device || device_dispatch_table(device)->CmdPipelineBarrier2KHR)) + return reinterpret_cast(vkCmdPipelineBarrier2KHR); + if (strcmp(pName, "vkCmdWriteTimestamp2KHR") == 0 && (!device || device_dispatch_table(device)->CmdWriteTimestamp2KHR)) + return reinterpret_cast(vkCmdWriteTimestamp2KHR); + if (strcmp(pName, "vkQueueSubmit2KHR") == 0 && (!device || device_dispatch_table(device)->QueueSubmit2KHR)) + return reinterpret_cast(vkQueueSubmit2KHR); + if (strcmp(pName, "vkCmdCopyBuffer2KHR") == 0 && (!device || device_dispatch_table(device)->CmdCopyBuffer2KHR)) + return reinterpret_cast(vkCmdCopyBuffer2KHR); + if (strcmp(pName, "vkCmdCopyImage2KHR") == 0 && (!device || device_dispatch_table(device)->CmdCopyImage2KHR)) + return reinterpret_cast(vkCmdCopyImage2KHR); + if (strcmp(pName, "vkCmdCopyBufferToImage2KHR") == 0 && (!device || device_dispatch_table(device)->CmdCopyBufferToImage2KHR)) + return reinterpret_cast(vkCmdCopyBufferToImage2KHR); + if (strcmp(pName, "vkCmdCopyImageToBuffer2KHR") == 0 && (!device || device_dispatch_table(device)->CmdCopyImageToBuffer2KHR)) + return reinterpret_cast(vkCmdCopyImageToBuffer2KHR); + if (strcmp(pName, "vkCmdBlitImage2KHR") == 0 && (!device || device_dispatch_table(device)->CmdBlitImage2KHR)) + return reinterpret_cast(vkCmdBlitImage2KHR); + if (strcmp(pName, "vkCmdResolveImage2KHR") == 0 && (!device || device_dispatch_table(device)->CmdResolveImage2KHR)) + return reinterpret_cast(vkCmdResolveImage2KHR); + if (strcmp(pName, "vkCmdTraceRaysIndirect2KHR") == 0 && (!device || device_dispatch_table(device)->CmdTraceRaysIndirect2KHR)) + return reinterpret_cast(vkCmdTraceRaysIndirect2KHR); + if (strcmp(pName, "vkGetDeviceBufferMemoryRequirementsKHR") == 0 && (!device || device_dispatch_table(device)->GetDeviceBufferMemoryRequirementsKHR)) + return reinterpret_cast(vkGetDeviceBufferMemoryRequirementsKHR); + if (strcmp(pName, "vkGetDeviceImageMemoryRequirementsKHR") == 0 && (!device || device_dispatch_table(device)->GetDeviceImageMemoryRequirementsKHR)) + return reinterpret_cast(vkGetDeviceImageMemoryRequirementsKHR); + if (strcmp(pName, "vkGetDeviceImageSparseMemoryRequirementsKHR") == 0 && (!device || device_dispatch_table(device)->GetDeviceImageSparseMemoryRequirementsKHR)) + return reinterpret_cast(vkGetDeviceImageSparseMemoryRequirementsKHR); + if (strcmp(pName, "vkCmdBindIndexBuffer2KHR") == 0 && (!device || device_dispatch_table(device)->CmdBindIndexBuffer2KHR)) + return reinterpret_cast(vkCmdBindIndexBuffer2KHR); + if (strcmp(pName, "vkGetRenderingAreaGranularityKHR") == 0 && (!device || device_dispatch_table(device)->GetRenderingAreaGranularityKHR)) + return reinterpret_cast(vkGetRenderingAreaGranularityKHR); + if (strcmp(pName, "vkGetDeviceImageSubresourceLayoutKHR") == 0 && (!device || device_dispatch_table(device)->GetDeviceImageSubresourceLayoutKHR)) + return reinterpret_cast(vkGetDeviceImageSubresourceLayoutKHR); + if (strcmp(pName, "vkGetImageSubresourceLayout2KHR") == 0 && (!device || device_dispatch_table(device)->GetImageSubresourceLayout2KHR)) + return reinterpret_cast(vkGetImageSubresourceLayout2KHR); + if (strcmp(pName, "vkWaitForPresent2KHR") == 0 && (!device || device_dispatch_table(device)->WaitForPresent2KHR)) + return reinterpret_cast(vkWaitForPresent2KHR); + if (strcmp(pName, "vkCreatePipelineBinariesKHR") == 0 && (!device || device_dispatch_table(device)->CreatePipelineBinariesKHR)) + return reinterpret_cast(vkCreatePipelineBinariesKHR); + if (strcmp(pName, "vkDestroyPipelineBinaryKHR") == 0 && (!device || device_dispatch_table(device)->DestroyPipelineBinaryKHR)) + return reinterpret_cast(vkDestroyPipelineBinaryKHR); + if (strcmp(pName, "vkGetPipelineKeyKHR") == 0 && (!device || device_dispatch_table(device)->GetPipelineKeyKHR)) + return reinterpret_cast(vkGetPipelineKeyKHR); + if (strcmp(pName, "vkGetPipelineBinaryDataKHR") == 0 && (!device || device_dispatch_table(device)->GetPipelineBinaryDataKHR)) + return reinterpret_cast(vkGetPipelineBinaryDataKHR); + if (strcmp(pName, "vkReleaseCapturedPipelineDataKHR") == 0 && (!device || device_dispatch_table(device)->ReleaseCapturedPipelineDataKHR)) + return reinterpret_cast(vkReleaseCapturedPipelineDataKHR); + if (strcmp(pName, "vkReleaseSwapchainImagesKHR") == 0 && (!device || device_dispatch_table(device)->ReleaseSwapchainImagesKHR)) + return reinterpret_cast(vkReleaseSwapchainImagesKHR); + if (strcmp(pName, "vkCmdSetLineStippleKHR") == 0 && (!device || device_dispatch_table(device)->CmdSetLineStippleKHR)) + return reinterpret_cast(vkCmdSetLineStippleKHR); + if (strcmp(pName, "vkGetCalibratedTimestampsKHR") == 0 && (!device || device_dispatch_table(device)->GetCalibratedTimestampsKHR)) + return reinterpret_cast(vkGetCalibratedTimestampsKHR); + if (strcmp(pName, "vkCmdBindDescriptorSets2KHR") == 0 && (!device || device_dispatch_table(device)->CmdBindDescriptorSets2KHR)) + return reinterpret_cast(vkCmdBindDescriptorSets2KHR); + if (strcmp(pName, "vkCmdPushConstants2KHR") == 0 && (!device || device_dispatch_table(device)->CmdPushConstants2KHR)) + return reinterpret_cast(vkCmdPushConstants2KHR); + if (strcmp(pName, "vkCmdPushDescriptorSet2KHR") == 0 && (!device || device_dispatch_table(device)->CmdPushDescriptorSet2KHR)) + return reinterpret_cast(vkCmdPushDescriptorSet2KHR); + if (strcmp(pName, "vkCmdPushDescriptorSetWithTemplate2KHR") == 0 && (!device || device_dispatch_table(device)->CmdPushDescriptorSetWithTemplate2KHR)) + return reinterpret_cast(vkCmdPushDescriptorSetWithTemplate2KHR); + if (strcmp(pName, "vkCmdSetDescriptorBufferOffsets2EXT") == 0 && (!device || device_dispatch_table(device)->CmdSetDescriptorBufferOffsets2EXT)) + return reinterpret_cast(vkCmdSetDescriptorBufferOffsets2EXT); + if (strcmp(pName, "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT") == 0 && (!device || device_dispatch_table(device)->CmdBindDescriptorBufferEmbeddedSamplers2EXT)) + return reinterpret_cast(vkCmdBindDescriptorBufferEmbeddedSamplers2EXT); + if (strcmp(pName, "vkCmdCopyMemoryIndirectKHR") == 0 && (!device || device_dispatch_table(device)->CmdCopyMemoryIndirectKHR)) + return reinterpret_cast(vkCmdCopyMemoryIndirectKHR); + if (strcmp(pName, "vkCmdCopyMemoryToImageIndirectKHR") == 0 && (!device || device_dispatch_table(device)->CmdCopyMemoryToImageIndirectKHR)) + return reinterpret_cast(vkCmdCopyMemoryToImageIndirectKHR); + if (strcmp(pName, "vkCmdEndRendering2KHR") == 0 && (!device || device_dispatch_table(device)->CmdEndRendering2KHR)) + return reinterpret_cast(vkCmdEndRendering2KHR); + if (strcmp(pName, "vkDebugMarkerSetObjectTagEXT") == 0 && (!device || device_dispatch_table(device)->DebugMarkerSetObjectTagEXT)) + return reinterpret_cast(vkDebugMarkerSetObjectTagEXT); + if (strcmp(pName, "vkDebugMarkerSetObjectNameEXT") == 0 && (!device || device_dispatch_table(device)->DebugMarkerSetObjectNameEXT)) + return reinterpret_cast(vkDebugMarkerSetObjectNameEXT); + if (strcmp(pName, "vkCmdDebugMarkerBeginEXT") == 0 && (!device || device_dispatch_table(device)->CmdDebugMarkerBeginEXT)) + return reinterpret_cast(vkCmdDebugMarkerBeginEXT); + if (strcmp(pName, "vkCmdDebugMarkerEndEXT") == 0 && (!device || device_dispatch_table(device)->CmdDebugMarkerEndEXT)) + return reinterpret_cast(vkCmdDebugMarkerEndEXT); + if (strcmp(pName, "vkCmdDebugMarkerInsertEXT") == 0 && (!device || device_dispatch_table(device)->CmdDebugMarkerInsertEXT)) + return reinterpret_cast(vkCmdDebugMarkerInsertEXT); + if (strcmp(pName, "vkCmdBindTransformFeedbackBuffersEXT") == 0 && (!device || device_dispatch_table(device)->CmdBindTransformFeedbackBuffersEXT)) + return reinterpret_cast(vkCmdBindTransformFeedbackBuffersEXT); + if (strcmp(pName, "vkCmdBeginTransformFeedbackEXT") == 0 && (!device || device_dispatch_table(device)->CmdBeginTransformFeedbackEXT)) + return reinterpret_cast(vkCmdBeginTransformFeedbackEXT); + if (strcmp(pName, "vkCmdEndTransformFeedbackEXT") == 0 && (!device || device_dispatch_table(device)->CmdEndTransformFeedbackEXT)) + return reinterpret_cast(vkCmdEndTransformFeedbackEXT); + if (strcmp(pName, "vkCmdBeginQueryIndexedEXT") == 0 && (!device || device_dispatch_table(device)->CmdBeginQueryIndexedEXT)) + return reinterpret_cast(vkCmdBeginQueryIndexedEXT); + if (strcmp(pName, "vkCmdEndQueryIndexedEXT") == 0 && (!device || device_dispatch_table(device)->CmdEndQueryIndexedEXT)) + return reinterpret_cast(vkCmdEndQueryIndexedEXT); + if (strcmp(pName, "vkCmdDrawIndirectByteCountEXT") == 0 && (!device || device_dispatch_table(device)->CmdDrawIndirectByteCountEXT)) + return reinterpret_cast(vkCmdDrawIndirectByteCountEXT); + if (strcmp(pName, "vkCreateCuModuleNVX") == 0 && (!device || device_dispatch_table(device)->CreateCuModuleNVX)) + return reinterpret_cast(vkCreateCuModuleNVX); + if (strcmp(pName, "vkCreateCuFunctionNVX") == 0 && (!device || device_dispatch_table(device)->CreateCuFunctionNVX)) + return reinterpret_cast(vkCreateCuFunctionNVX); + if (strcmp(pName, "vkDestroyCuModuleNVX") == 0 && (!device || device_dispatch_table(device)->DestroyCuModuleNVX)) + return reinterpret_cast(vkDestroyCuModuleNVX); + if (strcmp(pName, "vkDestroyCuFunctionNVX") == 0 && (!device || device_dispatch_table(device)->DestroyCuFunctionNVX)) + return reinterpret_cast(vkDestroyCuFunctionNVX); + if (strcmp(pName, "vkCmdCuLaunchKernelNVX") == 0 && (!device || device_dispatch_table(device)->CmdCuLaunchKernelNVX)) + return reinterpret_cast(vkCmdCuLaunchKernelNVX); + if (strcmp(pName, "vkGetImageViewHandleNVX") == 0 && (!device || device_dispatch_table(device)->GetImageViewHandleNVX)) + return reinterpret_cast(vkGetImageViewHandleNVX); + if (strcmp(pName, "vkGetImageViewHandle64NVX") == 0 && (!device || device_dispatch_table(device)->GetImageViewHandle64NVX)) + return reinterpret_cast(vkGetImageViewHandle64NVX); + if (strcmp(pName, "vkGetImageViewAddressNVX") == 0 && (!device || device_dispatch_table(device)->GetImageViewAddressNVX)) + return reinterpret_cast(vkGetImageViewAddressNVX); + if (strcmp(pName, "vkGetDeviceCombinedImageSamplerIndexNVX") == 0 && (!device || device_dispatch_table(device)->GetDeviceCombinedImageSamplerIndexNVX)) + return reinterpret_cast(vkGetDeviceCombinedImageSamplerIndexNVX); + if (strcmp(pName, "vkCmdDrawIndirectCountAMD") == 0 && (!device || device_dispatch_table(device)->CmdDrawIndirectCountAMD)) + return reinterpret_cast(vkCmdDrawIndirectCountAMD); + if (strcmp(pName, "vkCmdDrawIndexedIndirectCountAMD") == 0 && (!device || device_dispatch_table(device)->CmdDrawIndexedIndirectCountAMD)) + return reinterpret_cast(vkCmdDrawIndexedIndirectCountAMD); + if (strcmp(pName, "vkGetShaderInfoAMD") == 0 && (!device || device_dispatch_table(device)->GetShaderInfoAMD)) + return reinterpret_cast(vkGetShaderInfoAMD); +#if defined(VK_USE_PLATFORM_WIN32_KHR) + if (strcmp(pName, "vkGetMemoryWin32HandleNV") == 0 && (!device || device_dispatch_table(device)->GetMemoryWin32HandleNV)) + return reinterpret_cast(vkGetMemoryWin32HandleNV); +#endif // VK_USE_PLATFORM_WIN32_KHR + if (strcmp(pName, "vkCmdBeginConditionalRenderingEXT") == 0 && (!device || device_dispatch_table(device)->CmdBeginConditionalRenderingEXT)) + return reinterpret_cast(vkCmdBeginConditionalRenderingEXT); + if (strcmp(pName, "vkCmdEndConditionalRenderingEXT") == 0 && (!device || device_dispatch_table(device)->CmdEndConditionalRenderingEXT)) + return reinterpret_cast(vkCmdEndConditionalRenderingEXT); + if (strcmp(pName, "vkCmdSetViewportWScalingNV") == 0 && (!device || device_dispatch_table(device)->CmdSetViewportWScalingNV)) + return reinterpret_cast(vkCmdSetViewportWScalingNV); + if (strcmp(pName, "vkDisplayPowerControlEXT") == 0 && (!device || device_dispatch_table(device)->DisplayPowerControlEXT)) + return reinterpret_cast(vkDisplayPowerControlEXT); + if (strcmp(pName, "vkRegisterDeviceEventEXT") == 0 && (!device || device_dispatch_table(device)->RegisterDeviceEventEXT)) + return reinterpret_cast(vkRegisterDeviceEventEXT); + if (strcmp(pName, "vkRegisterDisplayEventEXT") == 0 && (!device || device_dispatch_table(device)->RegisterDisplayEventEXT)) + return reinterpret_cast(vkRegisterDisplayEventEXT); + if (strcmp(pName, "vkGetSwapchainCounterEXT") == 0 && (!device || device_dispatch_table(device)->GetSwapchainCounterEXT)) + return reinterpret_cast(vkGetSwapchainCounterEXT); + if (strcmp(pName, "vkGetRefreshCycleDurationGOOGLE") == 0 && (!device || device_dispatch_table(device)->GetRefreshCycleDurationGOOGLE)) + return reinterpret_cast(vkGetRefreshCycleDurationGOOGLE); + if (strcmp(pName, "vkGetPastPresentationTimingGOOGLE") == 0 && (!device || device_dispatch_table(device)->GetPastPresentationTimingGOOGLE)) + return reinterpret_cast(vkGetPastPresentationTimingGOOGLE); + if (strcmp(pName, "vkCmdSetDiscardRectangleEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetDiscardRectangleEXT)) + return reinterpret_cast(vkCmdSetDiscardRectangleEXT); + if (strcmp(pName, "vkCmdSetDiscardRectangleEnableEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetDiscardRectangleEnableEXT)) + return reinterpret_cast(vkCmdSetDiscardRectangleEnableEXT); + if (strcmp(pName, "vkCmdSetDiscardRectangleModeEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetDiscardRectangleModeEXT)) + return reinterpret_cast(vkCmdSetDiscardRectangleModeEXT); + if (strcmp(pName, "vkSetHdrMetadataEXT") == 0 && (!device || device_dispatch_table(device)->SetHdrMetadataEXT)) + return reinterpret_cast(vkSetHdrMetadataEXT); + if (strcmp(pName, "vkSetDebugUtilsObjectNameEXT") == 0 && (!device || device_dispatch_table(device)->SetDebugUtilsObjectNameEXT)) + return reinterpret_cast(vkSetDebugUtilsObjectNameEXT); + if (strcmp(pName, "vkSetDebugUtilsObjectTagEXT") == 0 && (!device || device_dispatch_table(device)->SetDebugUtilsObjectTagEXT)) + return reinterpret_cast(vkSetDebugUtilsObjectTagEXT); + if (strcmp(pName, "vkQueueBeginDebugUtilsLabelEXT") == 0 && (!device || device_dispatch_table(device)->QueueBeginDebugUtilsLabelEXT)) + return reinterpret_cast(vkQueueBeginDebugUtilsLabelEXT); + if (strcmp(pName, "vkQueueEndDebugUtilsLabelEXT") == 0 && (!device || device_dispatch_table(device)->QueueEndDebugUtilsLabelEXT)) + return reinterpret_cast(vkQueueEndDebugUtilsLabelEXT); + if (strcmp(pName, "vkQueueInsertDebugUtilsLabelEXT") == 0 && (!device || device_dispatch_table(device)->QueueInsertDebugUtilsLabelEXT)) + return reinterpret_cast(vkQueueInsertDebugUtilsLabelEXT); + if (strcmp(pName, "vkCmdBeginDebugUtilsLabelEXT") == 0 && (!device || device_dispatch_table(device)->CmdBeginDebugUtilsLabelEXT)) + return reinterpret_cast(vkCmdBeginDebugUtilsLabelEXT); + if (strcmp(pName, "vkCmdEndDebugUtilsLabelEXT") == 0 && (!device || device_dispatch_table(device)->CmdEndDebugUtilsLabelEXT)) + return reinterpret_cast(vkCmdEndDebugUtilsLabelEXT); + if (strcmp(pName, "vkCmdInsertDebugUtilsLabelEXT") == 0 && (!device || device_dispatch_table(device)->CmdInsertDebugUtilsLabelEXT)) + return reinterpret_cast(vkCmdInsertDebugUtilsLabelEXT); +#if defined(VK_USE_PLATFORM_ANDROID_KHR) + if (strcmp(pName, "vkGetAndroidHardwareBufferPropertiesANDROID") == 0 && (!device || device_dispatch_table(device)->GetAndroidHardwareBufferPropertiesANDROID)) + return reinterpret_cast(vkGetAndroidHardwareBufferPropertiesANDROID); + if (strcmp(pName, "vkGetMemoryAndroidHardwareBufferANDROID") == 0 && (!device || device_dispatch_table(device)->GetMemoryAndroidHardwareBufferANDROID)) + return reinterpret_cast(vkGetMemoryAndroidHardwareBufferANDROID); +#endif // VK_USE_PLATFORM_ANDROID_KHR +#if defined(VK_ENABLE_BETA_EXTENSIONS) + if (strcmp(pName, "vkCreateExecutionGraphPipelinesAMDX") == 0 && (!device || device_dispatch_table(device)->CreateExecutionGraphPipelinesAMDX)) + return reinterpret_cast(vkCreateExecutionGraphPipelinesAMDX); + if (strcmp(pName, "vkGetExecutionGraphPipelineScratchSizeAMDX") == 0 && (!device || device_dispatch_table(device)->GetExecutionGraphPipelineScratchSizeAMDX)) + return reinterpret_cast(vkGetExecutionGraphPipelineScratchSizeAMDX); + if (strcmp(pName, "vkGetExecutionGraphPipelineNodeIndexAMDX") == 0 && (!device || device_dispatch_table(device)->GetExecutionGraphPipelineNodeIndexAMDX)) + return reinterpret_cast(vkGetExecutionGraphPipelineNodeIndexAMDX); + if (strcmp(pName, "vkCmdInitializeGraphScratchMemoryAMDX") == 0 && (!device || device_dispatch_table(device)->CmdInitializeGraphScratchMemoryAMDX)) + return reinterpret_cast(vkCmdInitializeGraphScratchMemoryAMDX); + if (strcmp(pName, "vkCmdDispatchGraphAMDX") == 0 && (!device || device_dispatch_table(device)->CmdDispatchGraphAMDX)) + return reinterpret_cast(vkCmdDispatchGraphAMDX); + if (strcmp(pName, "vkCmdDispatchGraphIndirectAMDX") == 0 && (!device || device_dispatch_table(device)->CmdDispatchGraphIndirectAMDX)) + return reinterpret_cast(vkCmdDispatchGraphIndirectAMDX); + if (strcmp(pName, "vkCmdDispatchGraphIndirectCountAMDX") == 0 && (!device || device_dispatch_table(device)->CmdDispatchGraphIndirectCountAMDX)) + return reinterpret_cast(vkCmdDispatchGraphIndirectCountAMDX); +#endif // VK_ENABLE_BETA_EXTENSIONS + if (strcmp(pName, "vkWriteSamplerDescriptorsEXT") == 0 && (!device || device_dispatch_table(device)->WriteSamplerDescriptorsEXT)) + return reinterpret_cast(vkWriteSamplerDescriptorsEXT); + if (strcmp(pName, "vkWriteResourceDescriptorsEXT") == 0 && (!device || device_dispatch_table(device)->WriteResourceDescriptorsEXT)) + return reinterpret_cast(vkWriteResourceDescriptorsEXT); + if (strcmp(pName, "vkCmdBindSamplerHeapEXT") == 0 && (!device || device_dispatch_table(device)->CmdBindSamplerHeapEXT)) + return reinterpret_cast(vkCmdBindSamplerHeapEXT); + if (strcmp(pName, "vkCmdBindResourceHeapEXT") == 0 && (!device || device_dispatch_table(device)->CmdBindResourceHeapEXT)) + return reinterpret_cast(vkCmdBindResourceHeapEXT); + if (strcmp(pName, "vkCmdPushDataEXT") == 0 && (!device || device_dispatch_table(device)->CmdPushDataEXT)) + return reinterpret_cast(vkCmdPushDataEXT); + if (strcmp(pName, "vkGetImageOpaqueCaptureDataEXT") == 0 && (!device || device_dispatch_table(device)->GetImageOpaqueCaptureDataEXT)) + return reinterpret_cast(vkGetImageOpaqueCaptureDataEXT); + if (strcmp(pName, "vkRegisterCustomBorderColorEXT") == 0 && (!device || device_dispatch_table(device)->RegisterCustomBorderColorEXT)) + return reinterpret_cast(vkRegisterCustomBorderColorEXT); + if (strcmp(pName, "vkUnregisterCustomBorderColorEXT") == 0 && (!device || device_dispatch_table(device)->UnregisterCustomBorderColorEXT)) + return reinterpret_cast(vkUnregisterCustomBorderColorEXT); + if (strcmp(pName, "vkGetTensorOpaqueCaptureDataARM") == 0 && (!device || device_dispatch_table(device)->GetTensorOpaqueCaptureDataARM)) + return reinterpret_cast(vkGetTensorOpaqueCaptureDataARM); + if (strcmp(pName, "vkCmdSetSampleLocationsEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetSampleLocationsEXT)) + return reinterpret_cast(vkCmdSetSampleLocationsEXT); + if (strcmp(pName, "vkGetImageDrmFormatModifierPropertiesEXT") == 0 && (!device || device_dispatch_table(device)->GetImageDrmFormatModifierPropertiesEXT)) + return reinterpret_cast(vkGetImageDrmFormatModifierPropertiesEXT); + if (strcmp(pName, "vkCreateValidationCacheEXT") == 0 && (!device || device_dispatch_table(device)->CreateValidationCacheEXT)) + return reinterpret_cast(vkCreateValidationCacheEXT); + if (strcmp(pName, "vkDestroyValidationCacheEXT") == 0 && (!device || device_dispatch_table(device)->DestroyValidationCacheEXT)) + return reinterpret_cast(vkDestroyValidationCacheEXT); + if (strcmp(pName, "vkMergeValidationCachesEXT") == 0 && (!device || device_dispatch_table(device)->MergeValidationCachesEXT)) + return reinterpret_cast(vkMergeValidationCachesEXT); + if (strcmp(pName, "vkGetValidationCacheDataEXT") == 0 && (!device || device_dispatch_table(device)->GetValidationCacheDataEXT)) + return reinterpret_cast(vkGetValidationCacheDataEXT); + if (strcmp(pName, "vkCmdBindShadingRateImageNV") == 0 && (!device || device_dispatch_table(device)->CmdBindShadingRateImageNV)) + return reinterpret_cast(vkCmdBindShadingRateImageNV); + if (strcmp(pName, "vkCmdSetViewportShadingRatePaletteNV") == 0 && (!device || device_dispatch_table(device)->CmdSetViewportShadingRatePaletteNV)) + return reinterpret_cast(vkCmdSetViewportShadingRatePaletteNV); + if (strcmp(pName, "vkCmdSetCoarseSampleOrderNV") == 0 && (!device || device_dispatch_table(device)->CmdSetCoarseSampleOrderNV)) + return reinterpret_cast(vkCmdSetCoarseSampleOrderNV); + if (strcmp(pName, "vkCreateAccelerationStructureNV") == 0 && (!device || device_dispatch_table(device)->CreateAccelerationStructureNV)) + return reinterpret_cast(vkCreateAccelerationStructureNV); + if (strcmp(pName, "vkDestroyAccelerationStructureNV") == 0 && (!device || device_dispatch_table(device)->DestroyAccelerationStructureNV)) + return reinterpret_cast(vkDestroyAccelerationStructureNV); + if (strcmp(pName, "vkGetAccelerationStructureMemoryRequirementsNV") == 0 && (!device || device_dispatch_table(device)->GetAccelerationStructureMemoryRequirementsNV)) + return reinterpret_cast(vkGetAccelerationStructureMemoryRequirementsNV); + if (strcmp(pName, "vkBindAccelerationStructureMemoryNV") == 0 && (!device || device_dispatch_table(device)->BindAccelerationStructureMemoryNV)) + return reinterpret_cast(vkBindAccelerationStructureMemoryNV); + if (strcmp(pName, "vkCmdBuildAccelerationStructureNV") == 0 && (!device || device_dispatch_table(device)->CmdBuildAccelerationStructureNV)) + return reinterpret_cast(vkCmdBuildAccelerationStructureNV); + if (strcmp(pName, "vkCmdCopyAccelerationStructureNV") == 0 && (!device || device_dispatch_table(device)->CmdCopyAccelerationStructureNV)) + return reinterpret_cast(vkCmdCopyAccelerationStructureNV); + if (strcmp(pName, "vkCmdTraceRaysNV") == 0 && (!device || device_dispatch_table(device)->CmdTraceRaysNV)) + return reinterpret_cast(vkCmdTraceRaysNV); + if (strcmp(pName, "vkCreateRayTracingPipelinesNV") == 0 && (!device || device_dispatch_table(device)->CreateRayTracingPipelinesNV)) + return reinterpret_cast(vkCreateRayTracingPipelinesNV); + if (strcmp(pName, "vkGetRayTracingShaderGroupHandlesKHR") == 0 && (!device || device_dispatch_table(device)->GetRayTracingShaderGroupHandlesKHR)) + return reinterpret_cast(vkGetRayTracingShaderGroupHandlesKHR); + if (strcmp(pName, "vkGetRayTracingShaderGroupHandlesNV") == 0 && (!device || device_dispatch_table(device)->GetRayTracingShaderGroupHandlesNV)) + return reinterpret_cast(vkGetRayTracingShaderGroupHandlesNV); + if (strcmp(pName, "vkGetAccelerationStructureHandleNV") == 0 && (!device || device_dispatch_table(device)->GetAccelerationStructureHandleNV)) + return reinterpret_cast(vkGetAccelerationStructureHandleNV); + if (strcmp(pName, "vkCmdWriteAccelerationStructuresPropertiesNV") == 0 && (!device || device_dispatch_table(device)->CmdWriteAccelerationStructuresPropertiesNV)) + return reinterpret_cast(vkCmdWriteAccelerationStructuresPropertiesNV); + if (strcmp(pName, "vkCompileDeferredNV") == 0 && (!device || device_dispatch_table(device)->CompileDeferredNV)) + return reinterpret_cast(vkCompileDeferredNV); + if (strcmp(pName, "vkGetMemoryHostPointerPropertiesEXT") == 0 && (!device || device_dispatch_table(device)->GetMemoryHostPointerPropertiesEXT)) + return reinterpret_cast(vkGetMemoryHostPointerPropertiesEXT); + if (strcmp(pName, "vkCmdWriteBufferMarkerAMD") == 0 && (!device || device_dispatch_table(device)->CmdWriteBufferMarkerAMD)) + return reinterpret_cast(vkCmdWriteBufferMarkerAMD); + if (strcmp(pName, "vkCmdWriteBufferMarker2AMD") == 0 && (!device || device_dispatch_table(device)->CmdWriteBufferMarker2AMD)) + return reinterpret_cast(vkCmdWriteBufferMarker2AMD); + if (strcmp(pName, "vkGetCalibratedTimestampsEXT") == 0 && (!device || device_dispatch_table(device)->GetCalibratedTimestampsEXT)) + return reinterpret_cast(vkGetCalibratedTimestampsEXT); + if (strcmp(pName, "vkCmdDrawMeshTasksNV") == 0 && (!device || device_dispatch_table(device)->CmdDrawMeshTasksNV)) + return reinterpret_cast(vkCmdDrawMeshTasksNV); + if (strcmp(pName, "vkCmdDrawMeshTasksIndirectNV") == 0 && (!device || device_dispatch_table(device)->CmdDrawMeshTasksIndirectNV)) + return reinterpret_cast(vkCmdDrawMeshTasksIndirectNV); + if (strcmp(pName, "vkCmdDrawMeshTasksIndirectCountNV") == 0 && (!device || device_dispatch_table(device)->CmdDrawMeshTasksIndirectCountNV)) + return reinterpret_cast(vkCmdDrawMeshTasksIndirectCountNV); + if (strcmp(pName, "vkCmdSetExclusiveScissorEnableNV") == 0 && (!device || device_dispatch_table(device)->CmdSetExclusiveScissorEnableNV)) + return reinterpret_cast(vkCmdSetExclusiveScissorEnableNV); + if (strcmp(pName, "vkCmdSetExclusiveScissorNV") == 0 && (!device || device_dispatch_table(device)->CmdSetExclusiveScissorNV)) + return reinterpret_cast(vkCmdSetExclusiveScissorNV); + if (strcmp(pName, "vkCmdSetCheckpointNV") == 0 && (!device || device_dispatch_table(device)->CmdSetCheckpointNV)) + return reinterpret_cast(vkCmdSetCheckpointNV); + if (strcmp(pName, "vkGetQueueCheckpointDataNV") == 0 && (!device || device_dispatch_table(device)->GetQueueCheckpointDataNV)) + return reinterpret_cast(vkGetQueueCheckpointDataNV); + if (strcmp(pName, "vkGetQueueCheckpointData2NV") == 0 && (!device || device_dispatch_table(device)->GetQueueCheckpointData2NV)) + return reinterpret_cast(vkGetQueueCheckpointData2NV); + if (strcmp(pName, "vkSetSwapchainPresentTimingQueueSizeEXT") == 0 && (!device || device_dispatch_table(device)->SetSwapchainPresentTimingQueueSizeEXT)) + return reinterpret_cast(vkSetSwapchainPresentTimingQueueSizeEXT); + if (strcmp(pName, "vkGetSwapchainTimingPropertiesEXT") == 0 && (!device || device_dispatch_table(device)->GetSwapchainTimingPropertiesEXT)) + return reinterpret_cast(vkGetSwapchainTimingPropertiesEXT); + if (strcmp(pName, "vkGetSwapchainTimeDomainPropertiesEXT") == 0 && (!device || device_dispatch_table(device)->GetSwapchainTimeDomainPropertiesEXT)) + return reinterpret_cast(vkGetSwapchainTimeDomainPropertiesEXT); + if (strcmp(pName, "vkGetPastPresentationTimingEXT") == 0 && (!device || device_dispatch_table(device)->GetPastPresentationTimingEXT)) + return reinterpret_cast(vkGetPastPresentationTimingEXT); + if (strcmp(pName, "vkInitializePerformanceApiINTEL") == 0 && (!device || device_dispatch_table(device)->InitializePerformanceApiINTEL)) + return reinterpret_cast(vkInitializePerformanceApiINTEL); + if (strcmp(pName, "vkUninitializePerformanceApiINTEL") == 0 && (!device || device_dispatch_table(device)->UninitializePerformanceApiINTEL)) + return reinterpret_cast(vkUninitializePerformanceApiINTEL); + if (strcmp(pName, "vkCmdSetPerformanceMarkerINTEL") == 0 && (!device || device_dispatch_table(device)->CmdSetPerformanceMarkerINTEL)) + return reinterpret_cast(vkCmdSetPerformanceMarkerINTEL); + if (strcmp(pName, "vkCmdSetPerformanceStreamMarkerINTEL") == 0 && (!device || device_dispatch_table(device)->CmdSetPerformanceStreamMarkerINTEL)) + return reinterpret_cast(vkCmdSetPerformanceStreamMarkerINTEL); + if (strcmp(pName, "vkCmdSetPerformanceOverrideINTEL") == 0 && (!device || device_dispatch_table(device)->CmdSetPerformanceOverrideINTEL)) + return reinterpret_cast(vkCmdSetPerformanceOverrideINTEL); + if (strcmp(pName, "vkAcquirePerformanceConfigurationINTEL") == 0 && (!device || device_dispatch_table(device)->AcquirePerformanceConfigurationINTEL)) + return reinterpret_cast(vkAcquirePerformanceConfigurationINTEL); + if (strcmp(pName, "vkReleasePerformanceConfigurationINTEL") == 0 && (!device || device_dispatch_table(device)->ReleasePerformanceConfigurationINTEL)) + return reinterpret_cast(vkReleasePerformanceConfigurationINTEL); + if (strcmp(pName, "vkQueueSetPerformanceConfigurationINTEL") == 0 && (!device || device_dispatch_table(device)->QueueSetPerformanceConfigurationINTEL)) + return reinterpret_cast(vkQueueSetPerformanceConfigurationINTEL); + if (strcmp(pName, "vkGetPerformanceParameterINTEL") == 0 && (!device || device_dispatch_table(device)->GetPerformanceParameterINTEL)) + return reinterpret_cast(vkGetPerformanceParameterINTEL); + if (strcmp(pName, "vkSetLocalDimmingAMD") == 0 && (!device || device_dispatch_table(device)->SetLocalDimmingAMD)) + return reinterpret_cast(vkSetLocalDimmingAMD); + if (strcmp(pName, "vkGetBufferDeviceAddressEXT") == 0 && (!device || device_dispatch_table(device)->GetBufferDeviceAddressEXT)) + return reinterpret_cast(vkGetBufferDeviceAddressEXT); +#if defined(VK_USE_PLATFORM_WIN32_KHR) + if (strcmp(pName, "vkAcquireFullScreenExclusiveModeEXT") == 0 && (!device || device_dispatch_table(device)->AcquireFullScreenExclusiveModeEXT)) + return reinterpret_cast(vkAcquireFullScreenExclusiveModeEXT); + if (strcmp(pName, "vkReleaseFullScreenExclusiveModeEXT") == 0 && (!device || device_dispatch_table(device)->ReleaseFullScreenExclusiveModeEXT)) + return reinterpret_cast(vkReleaseFullScreenExclusiveModeEXT); + if (strcmp(pName, "vkGetDeviceGroupSurfacePresentModes2EXT") == 0 && (!device || device_dispatch_table(device)->GetDeviceGroupSurfacePresentModes2EXT)) + return reinterpret_cast(vkGetDeviceGroupSurfacePresentModes2EXT); +#endif // VK_USE_PLATFORM_WIN32_KHR + if (strcmp(pName, "vkCmdSetLineStippleEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetLineStippleEXT)) + return reinterpret_cast(vkCmdSetLineStippleEXT); + if (strcmp(pName, "vkResetQueryPoolEXT") == 0 && (!device || device_dispatch_table(device)->ResetQueryPoolEXT)) + return reinterpret_cast(vkResetQueryPoolEXT); + if (strcmp(pName, "vkCmdSetCullModeEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetCullModeEXT)) + return reinterpret_cast(vkCmdSetCullModeEXT); + if (strcmp(pName, "vkCmdSetFrontFaceEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetFrontFaceEXT)) + return reinterpret_cast(vkCmdSetFrontFaceEXT); + if (strcmp(pName, "vkCmdSetPrimitiveTopologyEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetPrimitiveTopologyEXT)) + return reinterpret_cast(vkCmdSetPrimitiveTopologyEXT); + if (strcmp(pName, "vkCmdSetViewportWithCountEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetViewportWithCountEXT)) + return reinterpret_cast(vkCmdSetViewportWithCountEXT); + if (strcmp(pName, "vkCmdSetScissorWithCountEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetScissorWithCountEXT)) + return reinterpret_cast(vkCmdSetScissorWithCountEXT); + if (strcmp(pName, "vkCmdBindVertexBuffers2EXT") == 0 && (!device || device_dispatch_table(device)->CmdBindVertexBuffers2EXT)) + return reinterpret_cast(vkCmdBindVertexBuffers2EXT); + if (strcmp(pName, "vkCmdSetDepthTestEnableEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetDepthTestEnableEXT)) + return reinterpret_cast(vkCmdSetDepthTestEnableEXT); + if (strcmp(pName, "vkCmdSetDepthWriteEnableEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetDepthWriteEnableEXT)) + return reinterpret_cast(vkCmdSetDepthWriteEnableEXT); + if (strcmp(pName, "vkCmdSetDepthCompareOpEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetDepthCompareOpEXT)) + return reinterpret_cast(vkCmdSetDepthCompareOpEXT); + if (strcmp(pName, "vkCmdSetDepthBoundsTestEnableEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetDepthBoundsTestEnableEXT)) + return reinterpret_cast(vkCmdSetDepthBoundsTestEnableEXT); + if (strcmp(pName, "vkCmdSetStencilTestEnableEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetStencilTestEnableEXT)) + return reinterpret_cast(vkCmdSetStencilTestEnableEXT); + if (strcmp(pName, "vkCmdSetStencilOpEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetStencilOpEXT)) + return reinterpret_cast(vkCmdSetStencilOpEXT); + if (strcmp(pName, "vkCopyMemoryToImageEXT") == 0 && (!device || device_dispatch_table(device)->CopyMemoryToImageEXT)) + return reinterpret_cast(vkCopyMemoryToImageEXT); + if (strcmp(pName, "vkCopyImageToMemoryEXT") == 0 && (!device || device_dispatch_table(device)->CopyImageToMemoryEXT)) + return reinterpret_cast(vkCopyImageToMemoryEXT); + if (strcmp(pName, "vkCopyImageToImageEXT") == 0 && (!device || device_dispatch_table(device)->CopyImageToImageEXT)) + return reinterpret_cast(vkCopyImageToImageEXT); + if (strcmp(pName, "vkTransitionImageLayoutEXT") == 0 && (!device || device_dispatch_table(device)->TransitionImageLayoutEXT)) + return reinterpret_cast(vkTransitionImageLayoutEXT); + if (strcmp(pName, "vkGetImageSubresourceLayout2EXT") == 0 && (!device || device_dispatch_table(device)->GetImageSubresourceLayout2EXT)) + return reinterpret_cast(vkGetImageSubresourceLayout2EXT); + if (strcmp(pName, "vkReleaseSwapchainImagesEXT") == 0 && (!device || device_dispatch_table(device)->ReleaseSwapchainImagesEXT)) + return reinterpret_cast(vkReleaseSwapchainImagesEXT); + if (strcmp(pName, "vkGetGeneratedCommandsMemoryRequirementsNV") == 0 && (!device || device_dispatch_table(device)->GetGeneratedCommandsMemoryRequirementsNV)) + return reinterpret_cast(vkGetGeneratedCommandsMemoryRequirementsNV); + if (strcmp(pName, "vkCmdPreprocessGeneratedCommandsNV") == 0 && (!device || device_dispatch_table(device)->CmdPreprocessGeneratedCommandsNV)) + return reinterpret_cast(vkCmdPreprocessGeneratedCommandsNV); + if (strcmp(pName, "vkCmdExecuteGeneratedCommandsNV") == 0 && (!device || device_dispatch_table(device)->CmdExecuteGeneratedCommandsNV)) + return reinterpret_cast(vkCmdExecuteGeneratedCommandsNV); + if (strcmp(pName, "vkCmdBindPipelineShaderGroupNV") == 0 && (!device || device_dispatch_table(device)->CmdBindPipelineShaderGroupNV)) + return reinterpret_cast(vkCmdBindPipelineShaderGroupNV); + if (strcmp(pName, "vkCreateIndirectCommandsLayoutNV") == 0 && (!device || device_dispatch_table(device)->CreateIndirectCommandsLayoutNV)) + return reinterpret_cast(vkCreateIndirectCommandsLayoutNV); + if (strcmp(pName, "vkDestroyIndirectCommandsLayoutNV") == 0 && (!device || device_dispatch_table(device)->DestroyIndirectCommandsLayoutNV)) + return reinterpret_cast(vkDestroyIndirectCommandsLayoutNV); + if (strcmp(pName, "vkCmdSetDepthBias2EXT") == 0 && (!device || device_dispatch_table(device)->CmdSetDepthBias2EXT)) + return reinterpret_cast(vkCmdSetDepthBias2EXT); + if (strcmp(pName, "vkCreatePrivateDataSlotEXT") == 0 && (!device || device_dispatch_table(device)->CreatePrivateDataSlotEXT)) + return reinterpret_cast(vkCreatePrivateDataSlotEXT); + if (strcmp(pName, "vkDestroyPrivateDataSlotEXT") == 0 && (!device || device_dispatch_table(device)->DestroyPrivateDataSlotEXT)) + return reinterpret_cast(vkDestroyPrivateDataSlotEXT); + if (strcmp(pName, "vkSetPrivateDataEXT") == 0 && (!device || device_dispatch_table(device)->SetPrivateDataEXT)) + return reinterpret_cast(vkSetPrivateDataEXT); + if (strcmp(pName, "vkGetPrivateDataEXT") == 0 && (!device || device_dispatch_table(device)->GetPrivateDataEXT)) + return reinterpret_cast(vkGetPrivateDataEXT); +#if defined(VK_ENABLE_BETA_EXTENSIONS) + if (strcmp(pName, "vkCreateCudaModuleNV") == 0 && (!device || device_dispatch_table(device)->CreateCudaModuleNV)) + return reinterpret_cast(vkCreateCudaModuleNV); + if (strcmp(pName, "vkGetCudaModuleCacheNV") == 0 && (!device || device_dispatch_table(device)->GetCudaModuleCacheNV)) + return reinterpret_cast(vkGetCudaModuleCacheNV); + if (strcmp(pName, "vkCreateCudaFunctionNV") == 0 && (!device || device_dispatch_table(device)->CreateCudaFunctionNV)) + return reinterpret_cast(vkCreateCudaFunctionNV); + if (strcmp(pName, "vkDestroyCudaModuleNV") == 0 && (!device || device_dispatch_table(device)->DestroyCudaModuleNV)) + return reinterpret_cast(vkDestroyCudaModuleNV); + if (strcmp(pName, "vkDestroyCudaFunctionNV") == 0 && (!device || device_dispatch_table(device)->DestroyCudaFunctionNV)) + return reinterpret_cast(vkDestroyCudaFunctionNV); + if (strcmp(pName, "vkCmdCudaLaunchKernelNV") == 0 && (!device || device_dispatch_table(device)->CmdCudaLaunchKernelNV)) + return reinterpret_cast(vkCmdCudaLaunchKernelNV); +#endif // VK_ENABLE_BETA_EXTENSIONS + if (strcmp(pName, "vkCmdDispatchTileQCOM") == 0 && (!device || device_dispatch_table(device)->CmdDispatchTileQCOM)) + return reinterpret_cast(vkCmdDispatchTileQCOM); + if (strcmp(pName, "vkCmdBeginPerTileExecutionQCOM") == 0 && (!device || device_dispatch_table(device)->CmdBeginPerTileExecutionQCOM)) + return reinterpret_cast(vkCmdBeginPerTileExecutionQCOM); + if (strcmp(pName, "vkCmdEndPerTileExecutionQCOM") == 0 && (!device || device_dispatch_table(device)->CmdEndPerTileExecutionQCOM)) + return reinterpret_cast(vkCmdEndPerTileExecutionQCOM); +#if defined(VK_USE_PLATFORM_METAL_EXT) + if (strcmp(pName, "vkExportMetalObjectsEXT") == 0 && (!device || device_dispatch_table(device)->ExportMetalObjectsEXT)) + return reinterpret_cast(vkExportMetalObjectsEXT); +#endif // VK_USE_PLATFORM_METAL_EXT + if (strcmp(pName, "vkGetDescriptorSetLayoutSizeEXT") == 0 && (!device || device_dispatch_table(device)->GetDescriptorSetLayoutSizeEXT)) + return reinterpret_cast(vkGetDescriptorSetLayoutSizeEXT); + if (strcmp(pName, "vkGetDescriptorSetLayoutBindingOffsetEXT") == 0 && (!device || device_dispatch_table(device)->GetDescriptorSetLayoutBindingOffsetEXT)) + return reinterpret_cast(vkGetDescriptorSetLayoutBindingOffsetEXT); + if (strcmp(pName, "vkGetDescriptorEXT") == 0 && (!device || device_dispatch_table(device)->GetDescriptorEXT)) + return reinterpret_cast(vkGetDescriptorEXT); + if (strcmp(pName, "vkCmdBindDescriptorBuffersEXT") == 0 && (!device || device_dispatch_table(device)->CmdBindDescriptorBuffersEXT)) + return reinterpret_cast(vkCmdBindDescriptorBuffersEXT); + if (strcmp(pName, "vkCmdSetDescriptorBufferOffsetsEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetDescriptorBufferOffsetsEXT)) + return reinterpret_cast(vkCmdSetDescriptorBufferOffsetsEXT); + if (strcmp(pName, "vkCmdBindDescriptorBufferEmbeddedSamplersEXT") == 0 && (!device || device_dispatch_table(device)->CmdBindDescriptorBufferEmbeddedSamplersEXT)) + return reinterpret_cast(vkCmdBindDescriptorBufferEmbeddedSamplersEXT); + if (strcmp(pName, "vkGetBufferOpaqueCaptureDescriptorDataEXT") == 0 && (!device || device_dispatch_table(device)->GetBufferOpaqueCaptureDescriptorDataEXT)) + return reinterpret_cast(vkGetBufferOpaqueCaptureDescriptorDataEXT); + if (strcmp(pName, "vkGetImageOpaqueCaptureDescriptorDataEXT") == 0 && (!device || device_dispatch_table(device)->GetImageOpaqueCaptureDescriptorDataEXT)) + return reinterpret_cast(vkGetImageOpaqueCaptureDescriptorDataEXT); + if (strcmp(pName, "vkGetImageViewOpaqueCaptureDescriptorDataEXT") == 0 && (!device || device_dispatch_table(device)->GetImageViewOpaqueCaptureDescriptorDataEXT)) + return reinterpret_cast(vkGetImageViewOpaqueCaptureDescriptorDataEXT); + if (strcmp(pName, "vkGetSamplerOpaqueCaptureDescriptorDataEXT") == 0 && (!device || device_dispatch_table(device)->GetSamplerOpaqueCaptureDescriptorDataEXT)) + return reinterpret_cast(vkGetSamplerOpaqueCaptureDescriptorDataEXT); + if (strcmp(pName, "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT") == 0 && (!device || device_dispatch_table(device)->GetAccelerationStructureOpaqueCaptureDescriptorDataEXT)) + return reinterpret_cast(vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT); + if (strcmp(pName, "vkCmdSetFragmentShadingRateEnumNV") == 0 && (!device || device_dispatch_table(device)->CmdSetFragmentShadingRateEnumNV)) + return reinterpret_cast(vkCmdSetFragmentShadingRateEnumNV); + if (strcmp(pName, "vkGetDeviceFaultInfoEXT") == 0 && (!device || device_dispatch_table(device)->GetDeviceFaultInfoEXT)) + return reinterpret_cast(vkGetDeviceFaultInfoEXT); + if (strcmp(pName, "vkCmdSetVertexInputEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetVertexInputEXT)) + return reinterpret_cast(vkCmdSetVertexInputEXT); +#if defined(VK_USE_PLATFORM_FUCHSIA) + if (strcmp(pName, "vkGetMemoryZirconHandleFUCHSIA") == 0 && (!device || device_dispatch_table(device)->GetMemoryZirconHandleFUCHSIA)) + return reinterpret_cast(vkGetMemoryZirconHandleFUCHSIA); + if (strcmp(pName, "vkGetMemoryZirconHandlePropertiesFUCHSIA") == 0 && (!device || device_dispatch_table(device)->GetMemoryZirconHandlePropertiesFUCHSIA)) + return reinterpret_cast(vkGetMemoryZirconHandlePropertiesFUCHSIA); + if (strcmp(pName, "vkImportSemaphoreZirconHandleFUCHSIA") == 0 && (!device || device_dispatch_table(device)->ImportSemaphoreZirconHandleFUCHSIA)) + return reinterpret_cast(vkImportSemaphoreZirconHandleFUCHSIA); + if (strcmp(pName, "vkGetSemaphoreZirconHandleFUCHSIA") == 0 && (!device || device_dispatch_table(device)->GetSemaphoreZirconHandleFUCHSIA)) + return reinterpret_cast(vkGetSemaphoreZirconHandleFUCHSIA); + if (strcmp(pName, "vkCreateBufferCollectionFUCHSIA") == 0 && (!device || device_dispatch_table(device)->CreateBufferCollectionFUCHSIA)) + return reinterpret_cast(vkCreateBufferCollectionFUCHSIA); + if (strcmp(pName, "vkSetBufferCollectionImageConstraintsFUCHSIA") == 0 && (!device || device_dispatch_table(device)->SetBufferCollectionImageConstraintsFUCHSIA)) + return reinterpret_cast(vkSetBufferCollectionImageConstraintsFUCHSIA); + if (strcmp(pName, "vkSetBufferCollectionBufferConstraintsFUCHSIA") == 0 && (!device || device_dispatch_table(device)->SetBufferCollectionBufferConstraintsFUCHSIA)) + return reinterpret_cast(vkSetBufferCollectionBufferConstraintsFUCHSIA); + if (strcmp(pName, "vkDestroyBufferCollectionFUCHSIA") == 0 && (!device || device_dispatch_table(device)->DestroyBufferCollectionFUCHSIA)) + return reinterpret_cast(vkDestroyBufferCollectionFUCHSIA); + if (strcmp(pName, "vkGetBufferCollectionPropertiesFUCHSIA") == 0 && (!device || device_dispatch_table(device)->GetBufferCollectionPropertiesFUCHSIA)) + return reinterpret_cast(vkGetBufferCollectionPropertiesFUCHSIA); +#endif // VK_USE_PLATFORM_FUCHSIA + if (strcmp(pName, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI") == 0 && (!device || device_dispatch_table(device)->GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI)) + return reinterpret_cast(vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI); + if (strcmp(pName, "vkCmdSubpassShadingHUAWEI") == 0 && (!device || device_dispatch_table(device)->CmdSubpassShadingHUAWEI)) + return reinterpret_cast(vkCmdSubpassShadingHUAWEI); + if (strcmp(pName, "vkCmdBindInvocationMaskHUAWEI") == 0 && (!device || device_dispatch_table(device)->CmdBindInvocationMaskHUAWEI)) + return reinterpret_cast(vkCmdBindInvocationMaskHUAWEI); + if (strcmp(pName, "vkGetMemoryRemoteAddressNV") == 0 && (!device || device_dispatch_table(device)->GetMemoryRemoteAddressNV)) + return reinterpret_cast(vkGetMemoryRemoteAddressNV); + if (strcmp(pName, "vkGetPipelinePropertiesEXT") == 0 && (!device || device_dispatch_table(device)->GetPipelinePropertiesEXT)) + return reinterpret_cast(vkGetPipelinePropertiesEXT); + if (strcmp(pName, "vkCmdSetPatchControlPointsEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetPatchControlPointsEXT)) + return reinterpret_cast(vkCmdSetPatchControlPointsEXT); + if (strcmp(pName, "vkCmdSetRasterizerDiscardEnableEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetRasterizerDiscardEnableEXT)) + return reinterpret_cast(vkCmdSetRasterizerDiscardEnableEXT); + if (strcmp(pName, "vkCmdSetDepthBiasEnableEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetDepthBiasEnableEXT)) + return reinterpret_cast(vkCmdSetDepthBiasEnableEXT); + if (strcmp(pName, "vkCmdSetLogicOpEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetLogicOpEXT)) + return reinterpret_cast(vkCmdSetLogicOpEXT); + if (strcmp(pName, "vkCmdSetPrimitiveRestartEnableEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetPrimitiveRestartEnableEXT)) + return reinterpret_cast(vkCmdSetPrimitiveRestartEnableEXT); + if (strcmp(pName, "vkCmdSetColorWriteEnableEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetColorWriteEnableEXT)) + return reinterpret_cast(vkCmdSetColorWriteEnableEXT); + if (strcmp(pName, "vkCmdDrawMultiEXT") == 0 && (!device || device_dispatch_table(device)->CmdDrawMultiEXT)) + return reinterpret_cast(vkCmdDrawMultiEXT); + if (strcmp(pName, "vkCmdDrawMultiIndexedEXT") == 0 && (!device || device_dispatch_table(device)->CmdDrawMultiIndexedEXT)) + return reinterpret_cast(vkCmdDrawMultiIndexedEXT); + if (strcmp(pName, "vkCreateMicromapEXT") == 0 && (!device || device_dispatch_table(device)->CreateMicromapEXT)) + return reinterpret_cast(vkCreateMicromapEXT); + if (strcmp(pName, "vkDestroyMicromapEXT") == 0 && (!device || device_dispatch_table(device)->DestroyMicromapEXT)) + return reinterpret_cast(vkDestroyMicromapEXT); + if (strcmp(pName, "vkCmdBuildMicromapsEXT") == 0 && (!device || device_dispatch_table(device)->CmdBuildMicromapsEXT)) + return reinterpret_cast(vkCmdBuildMicromapsEXT); + if (strcmp(pName, "vkBuildMicromapsEXT") == 0 && (!device || device_dispatch_table(device)->BuildMicromapsEXT)) + return reinterpret_cast(vkBuildMicromapsEXT); + if (strcmp(pName, "vkCopyMicromapEXT") == 0 && (!device || device_dispatch_table(device)->CopyMicromapEXT)) + return reinterpret_cast(vkCopyMicromapEXT); + if (strcmp(pName, "vkCopyMicromapToMemoryEXT") == 0 && (!device || device_dispatch_table(device)->CopyMicromapToMemoryEXT)) + return reinterpret_cast(vkCopyMicromapToMemoryEXT); + if (strcmp(pName, "vkCopyMemoryToMicromapEXT") == 0 && (!device || device_dispatch_table(device)->CopyMemoryToMicromapEXT)) + return reinterpret_cast(vkCopyMemoryToMicromapEXT); + if (strcmp(pName, "vkWriteMicromapsPropertiesEXT") == 0 && (!device || device_dispatch_table(device)->WriteMicromapsPropertiesEXT)) + return reinterpret_cast(vkWriteMicromapsPropertiesEXT); + if (strcmp(pName, "vkCmdCopyMicromapEXT") == 0 && (!device || device_dispatch_table(device)->CmdCopyMicromapEXT)) + return reinterpret_cast(vkCmdCopyMicromapEXT); + if (strcmp(pName, "vkCmdCopyMicromapToMemoryEXT") == 0 && (!device || device_dispatch_table(device)->CmdCopyMicromapToMemoryEXT)) + return reinterpret_cast(vkCmdCopyMicromapToMemoryEXT); + if (strcmp(pName, "vkCmdCopyMemoryToMicromapEXT") == 0 && (!device || device_dispatch_table(device)->CmdCopyMemoryToMicromapEXT)) + return reinterpret_cast(vkCmdCopyMemoryToMicromapEXT); + if (strcmp(pName, "vkCmdWriteMicromapsPropertiesEXT") == 0 && (!device || device_dispatch_table(device)->CmdWriteMicromapsPropertiesEXT)) + return reinterpret_cast(vkCmdWriteMicromapsPropertiesEXT); + if (strcmp(pName, "vkGetDeviceMicromapCompatibilityEXT") == 0 && (!device || device_dispatch_table(device)->GetDeviceMicromapCompatibilityEXT)) + return reinterpret_cast(vkGetDeviceMicromapCompatibilityEXT); + if (strcmp(pName, "vkGetMicromapBuildSizesEXT") == 0 && (!device || device_dispatch_table(device)->GetMicromapBuildSizesEXT)) + return reinterpret_cast(vkGetMicromapBuildSizesEXT); + if (strcmp(pName, "vkCmdDrawClusterHUAWEI") == 0 && (!device || device_dispatch_table(device)->CmdDrawClusterHUAWEI)) + return reinterpret_cast(vkCmdDrawClusterHUAWEI); + if (strcmp(pName, "vkCmdDrawClusterIndirectHUAWEI") == 0 && (!device || device_dispatch_table(device)->CmdDrawClusterIndirectHUAWEI)) + return reinterpret_cast(vkCmdDrawClusterIndirectHUAWEI); + if (strcmp(pName, "vkSetDeviceMemoryPriorityEXT") == 0 && (!device || device_dispatch_table(device)->SetDeviceMemoryPriorityEXT)) + return reinterpret_cast(vkSetDeviceMemoryPriorityEXT); + if (strcmp(pName, "vkGetDescriptorSetLayoutHostMappingInfoVALVE") == 0 && (!device || device_dispatch_table(device)->GetDescriptorSetLayoutHostMappingInfoVALVE)) + return reinterpret_cast(vkGetDescriptorSetLayoutHostMappingInfoVALVE); + if (strcmp(pName, "vkGetDescriptorSetHostMappingVALVE") == 0 && (!device || device_dispatch_table(device)->GetDescriptorSetHostMappingVALVE)) + return reinterpret_cast(vkGetDescriptorSetHostMappingVALVE); + if (strcmp(pName, "vkCmdCopyMemoryIndirectNV") == 0 && (!device || device_dispatch_table(device)->CmdCopyMemoryIndirectNV)) + return reinterpret_cast(vkCmdCopyMemoryIndirectNV); + if (strcmp(pName, "vkCmdCopyMemoryToImageIndirectNV") == 0 && (!device || device_dispatch_table(device)->CmdCopyMemoryToImageIndirectNV)) + return reinterpret_cast(vkCmdCopyMemoryToImageIndirectNV); + if (strcmp(pName, "vkCmdDecompressMemoryNV") == 0 && (!device || device_dispatch_table(device)->CmdDecompressMemoryNV)) + return reinterpret_cast(vkCmdDecompressMemoryNV); + if (strcmp(pName, "vkCmdDecompressMemoryIndirectCountNV") == 0 && (!device || device_dispatch_table(device)->CmdDecompressMemoryIndirectCountNV)) + return reinterpret_cast(vkCmdDecompressMemoryIndirectCountNV); + if (strcmp(pName, "vkGetPipelineIndirectMemoryRequirementsNV") == 0 && (!device || device_dispatch_table(device)->GetPipelineIndirectMemoryRequirementsNV)) + return reinterpret_cast(vkGetPipelineIndirectMemoryRequirementsNV); + if (strcmp(pName, "vkCmdUpdatePipelineIndirectBufferNV") == 0 && (!device || device_dispatch_table(device)->CmdUpdatePipelineIndirectBufferNV)) + return reinterpret_cast(vkCmdUpdatePipelineIndirectBufferNV); + if (strcmp(pName, "vkGetPipelineIndirectDeviceAddressNV") == 0 && (!device || device_dispatch_table(device)->GetPipelineIndirectDeviceAddressNV)) + return reinterpret_cast(vkGetPipelineIndirectDeviceAddressNV); +#if defined(VK_USE_PLATFORM_OHOS) + if (strcmp(pName, "vkGetNativeBufferPropertiesOHOS") == 0 && (!device || device_dispatch_table(device)->GetNativeBufferPropertiesOHOS)) + return reinterpret_cast(vkGetNativeBufferPropertiesOHOS); + if (strcmp(pName, "vkGetMemoryNativeBufferOHOS") == 0 && (!device || device_dispatch_table(device)->GetMemoryNativeBufferOHOS)) + return reinterpret_cast(vkGetMemoryNativeBufferOHOS); +#endif // VK_USE_PLATFORM_OHOS + if (strcmp(pName, "vkCmdSetDepthClampEnableEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetDepthClampEnableEXT)) + return reinterpret_cast(vkCmdSetDepthClampEnableEXT); + if (strcmp(pName, "vkCmdSetPolygonModeEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetPolygonModeEXT)) + return reinterpret_cast(vkCmdSetPolygonModeEXT); + if (strcmp(pName, "vkCmdSetRasterizationSamplesEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetRasterizationSamplesEXT)) + return reinterpret_cast(vkCmdSetRasterizationSamplesEXT); + if (strcmp(pName, "vkCmdSetSampleMaskEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetSampleMaskEXT)) + return reinterpret_cast(vkCmdSetSampleMaskEXT); + if (strcmp(pName, "vkCmdSetAlphaToCoverageEnableEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetAlphaToCoverageEnableEXT)) + return reinterpret_cast(vkCmdSetAlphaToCoverageEnableEXT); + if (strcmp(pName, "vkCmdSetAlphaToOneEnableEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetAlphaToOneEnableEXT)) + return reinterpret_cast(vkCmdSetAlphaToOneEnableEXT); + if (strcmp(pName, "vkCmdSetLogicOpEnableEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetLogicOpEnableEXT)) + return reinterpret_cast(vkCmdSetLogicOpEnableEXT); + if (strcmp(pName, "vkCmdSetColorBlendEnableEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetColorBlendEnableEXT)) + return reinterpret_cast(vkCmdSetColorBlendEnableEXT); + if (strcmp(pName, "vkCmdSetColorBlendEquationEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetColorBlendEquationEXT)) + return reinterpret_cast(vkCmdSetColorBlendEquationEXT); + if (strcmp(pName, "vkCmdSetColorWriteMaskEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetColorWriteMaskEXT)) + return reinterpret_cast(vkCmdSetColorWriteMaskEXT); + if (strcmp(pName, "vkCmdSetTessellationDomainOriginEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetTessellationDomainOriginEXT)) + return reinterpret_cast(vkCmdSetTessellationDomainOriginEXT); + if (strcmp(pName, "vkCmdSetRasterizationStreamEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetRasterizationStreamEXT)) + return reinterpret_cast(vkCmdSetRasterizationStreamEXT); + if (strcmp(pName, "vkCmdSetConservativeRasterizationModeEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetConservativeRasterizationModeEXT)) + return reinterpret_cast(vkCmdSetConservativeRasterizationModeEXT); + if (strcmp(pName, "vkCmdSetExtraPrimitiveOverestimationSizeEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetExtraPrimitiveOverestimationSizeEXT)) + return reinterpret_cast(vkCmdSetExtraPrimitiveOverestimationSizeEXT); + if (strcmp(pName, "vkCmdSetDepthClipEnableEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetDepthClipEnableEXT)) + return reinterpret_cast(vkCmdSetDepthClipEnableEXT); + if (strcmp(pName, "vkCmdSetSampleLocationsEnableEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetSampleLocationsEnableEXT)) + return reinterpret_cast(vkCmdSetSampleLocationsEnableEXT); + if (strcmp(pName, "vkCmdSetColorBlendAdvancedEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetColorBlendAdvancedEXT)) + return reinterpret_cast(vkCmdSetColorBlendAdvancedEXT); + if (strcmp(pName, "vkCmdSetProvokingVertexModeEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetProvokingVertexModeEXT)) + return reinterpret_cast(vkCmdSetProvokingVertexModeEXT); + if (strcmp(pName, "vkCmdSetLineRasterizationModeEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetLineRasterizationModeEXT)) + return reinterpret_cast(vkCmdSetLineRasterizationModeEXT); + if (strcmp(pName, "vkCmdSetLineStippleEnableEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetLineStippleEnableEXT)) + return reinterpret_cast(vkCmdSetLineStippleEnableEXT); + if (strcmp(pName, "vkCmdSetDepthClipNegativeOneToOneEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetDepthClipNegativeOneToOneEXT)) + return reinterpret_cast(vkCmdSetDepthClipNegativeOneToOneEXT); + if (strcmp(pName, "vkCmdSetViewportWScalingEnableNV") == 0 && (!device || device_dispatch_table(device)->CmdSetViewportWScalingEnableNV)) + return reinterpret_cast(vkCmdSetViewportWScalingEnableNV); + if (strcmp(pName, "vkCmdSetViewportSwizzleNV") == 0 && (!device || device_dispatch_table(device)->CmdSetViewportSwizzleNV)) + return reinterpret_cast(vkCmdSetViewportSwizzleNV); + if (strcmp(pName, "vkCmdSetCoverageToColorEnableNV") == 0 && (!device || device_dispatch_table(device)->CmdSetCoverageToColorEnableNV)) + return reinterpret_cast(vkCmdSetCoverageToColorEnableNV); + if (strcmp(pName, "vkCmdSetCoverageToColorLocationNV") == 0 && (!device || device_dispatch_table(device)->CmdSetCoverageToColorLocationNV)) + return reinterpret_cast(vkCmdSetCoverageToColorLocationNV); + if (strcmp(pName, "vkCmdSetCoverageModulationModeNV") == 0 && (!device || device_dispatch_table(device)->CmdSetCoverageModulationModeNV)) + return reinterpret_cast(vkCmdSetCoverageModulationModeNV); + if (strcmp(pName, "vkCmdSetCoverageModulationTableEnableNV") == 0 && (!device || device_dispatch_table(device)->CmdSetCoverageModulationTableEnableNV)) + return reinterpret_cast(vkCmdSetCoverageModulationTableEnableNV); + if (strcmp(pName, "vkCmdSetCoverageModulationTableNV") == 0 && (!device || device_dispatch_table(device)->CmdSetCoverageModulationTableNV)) + return reinterpret_cast(vkCmdSetCoverageModulationTableNV); + if (strcmp(pName, "vkCmdSetShadingRateImageEnableNV") == 0 && (!device || device_dispatch_table(device)->CmdSetShadingRateImageEnableNV)) + return reinterpret_cast(vkCmdSetShadingRateImageEnableNV); + if (strcmp(pName, "vkCmdSetRepresentativeFragmentTestEnableNV") == 0 && (!device || device_dispatch_table(device)->CmdSetRepresentativeFragmentTestEnableNV)) + return reinterpret_cast(vkCmdSetRepresentativeFragmentTestEnableNV); + if (strcmp(pName, "vkCmdSetCoverageReductionModeNV") == 0 && (!device || device_dispatch_table(device)->CmdSetCoverageReductionModeNV)) + return reinterpret_cast(vkCmdSetCoverageReductionModeNV); + if (strcmp(pName, "vkCreateTensorARM") == 0 && (!device || device_dispatch_table(device)->CreateTensorARM)) + return reinterpret_cast(vkCreateTensorARM); + if (strcmp(pName, "vkDestroyTensorARM") == 0 && (!device || device_dispatch_table(device)->DestroyTensorARM)) + return reinterpret_cast(vkDestroyTensorARM); + if (strcmp(pName, "vkCreateTensorViewARM") == 0 && (!device || device_dispatch_table(device)->CreateTensorViewARM)) + return reinterpret_cast(vkCreateTensorViewARM); + if (strcmp(pName, "vkDestroyTensorViewARM") == 0 && (!device || device_dispatch_table(device)->DestroyTensorViewARM)) + return reinterpret_cast(vkDestroyTensorViewARM); + if (strcmp(pName, "vkGetTensorMemoryRequirementsARM") == 0 && (!device || device_dispatch_table(device)->GetTensorMemoryRequirementsARM)) + return reinterpret_cast(vkGetTensorMemoryRequirementsARM); + if (strcmp(pName, "vkBindTensorMemoryARM") == 0 && (!device || device_dispatch_table(device)->BindTensorMemoryARM)) + return reinterpret_cast(vkBindTensorMemoryARM); + if (strcmp(pName, "vkGetDeviceTensorMemoryRequirementsARM") == 0 && (!device || device_dispatch_table(device)->GetDeviceTensorMemoryRequirementsARM)) + return reinterpret_cast(vkGetDeviceTensorMemoryRequirementsARM); + if (strcmp(pName, "vkCmdCopyTensorARM") == 0 && (!device || device_dispatch_table(device)->CmdCopyTensorARM)) + return reinterpret_cast(vkCmdCopyTensorARM); + if (strcmp(pName, "vkGetTensorOpaqueCaptureDescriptorDataARM") == 0 && (!device || device_dispatch_table(device)->GetTensorOpaqueCaptureDescriptorDataARM)) + return reinterpret_cast(vkGetTensorOpaqueCaptureDescriptorDataARM); + if (strcmp(pName, "vkGetTensorViewOpaqueCaptureDescriptorDataARM") == 0 && (!device || device_dispatch_table(device)->GetTensorViewOpaqueCaptureDescriptorDataARM)) + return reinterpret_cast(vkGetTensorViewOpaqueCaptureDescriptorDataARM); + if (strcmp(pName, "vkGetShaderModuleIdentifierEXT") == 0 && (!device || device_dispatch_table(device)->GetShaderModuleIdentifierEXT)) + return reinterpret_cast(vkGetShaderModuleIdentifierEXT); + if (strcmp(pName, "vkGetShaderModuleCreateInfoIdentifierEXT") == 0 && (!device || device_dispatch_table(device)->GetShaderModuleCreateInfoIdentifierEXT)) + return reinterpret_cast(vkGetShaderModuleCreateInfoIdentifierEXT); + if (strcmp(pName, "vkCreateOpticalFlowSessionNV") == 0 && (!device || device_dispatch_table(device)->CreateOpticalFlowSessionNV)) + return reinterpret_cast(vkCreateOpticalFlowSessionNV); + if (strcmp(pName, "vkDestroyOpticalFlowSessionNV") == 0 && (!device || device_dispatch_table(device)->DestroyOpticalFlowSessionNV)) + return reinterpret_cast(vkDestroyOpticalFlowSessionNV); + if (strcmp(pName, "vkBindOpticalFlowSessionImageNV") == 0 && (!device || device_dispatch_table(device)->BindOpticalFlowSessionImageNV)) + return reinterpret_cast(vkBindOpticalFlowSessionImageNV); + if (strcmp(pName, "vkCmdOpticalFlowExecuteNV") == 0 && (!device || device_dispatch_table(device)->CmdOpticalFlowExecuteNV)) + return reinterpret_cast(vkCmdOpticalFlowExecuteNV); + if (strcmp(pName, "vkAntiLagUpdateAMD") == 0 && (!device || device_dispatch_table(device)->AntiLagUpdateAMD)) + return reinterpret_cast(vkAntiLagUpdateAMD); + if (strcmp(pName, "vkCreateShadersEXT") == 0 && (!device || device_dispatch_table(device)->CreateShadersEXT)) + return reinterpret_cast(vkCreateShadersEXT); + if (strcmp(pName, "vkDestroyShaderEXT") == 0 && (!device || device_dispatch_table(device)->DestroyShaderEXT)) + return reinterpret_cast(vkDestroyShaderEXT); + if (strcmp(pName, "vkGetShaderBinaryDataEXT") == 0 && (!device || device_dispatch_table(device)->GetShaderBinaryDataEXT)) + return reinterpret_cast(vkGetShaderBinaryDataEXT); + if (strcmp(pName, "vkCmdBindShadersEXT") == 0 && (!device || device_dispatch_table(device)->CmdBindShadersEXT)) + return reinterpret_cast(vkCmdBindShadersEXT); + if (strcmp(pName, "vkCmdSetDepthClampRangeEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetDepthClampRangeEXT)) + return reinterpret_cast(vkCmdSetDepthClampRangeEXT); + if (strcmp(pName, "vkGetFramebufferTilePropertiesQCOM") == 0 && (!device || device_dispatch_table(device)->GetFramebufferTilePropertiesQCOM)) + return reinterpret_cast(vkGetFramebufferTilePropertiesQCOM); + if (strcmp(pName, "vkGetDynamicRenderingTilePropertiesQCOM") == 0 && (!device || device_dispatch_table(device)->GetDynamicRenderingTilePropertiesQCOM)) + return reinterpret_cast(vkGetDynamicRenderingTilePropertiesQCOM); + if (strcmp(pName, "vkConvertCooperativeVectorMatrixNV") == 0 && (!device || device_dispatch_table(device)->ConvertCooperativeVectorMatrixNV)) + return reinterpret_cast(vkConvertCooperativeVectorMatrixNV); + if (strcmp(pName, "vkCmdConvertCooperativeVectorMatrixNV") == 0 && (!device || device_dispatch_table(device)->CmdConvertCooperativeVectorMatrixNV)) + return reinterpret_cast(vkCmdConvertCooperativeVectorMatrixNV); + if (strcmp(pName, "vkSetLatencySleepModeNV") == 0 && (!device || device_dispatch_table(device)->SetLatencySleepModeNV)) + return reinterpret_cast(vkSetLatencySleepModeNV); + if (strcmp(pName, "vkLatencySleepNV") == 0 && (!device || device_dispatch_table(device)->LatencySleepNV)) + return reinterpret_cast(vkLatencySleepNV); + if (strcmp(pName, "vkSetLatencyMarkerNV") == 0 && (!device || device_dispatch_table(device)->SetLatencyMarkerNV)) + return reinterpret_cast(vkSetLatencyMarkerNV); + if (strcmp(pName, "vkGetLatencyTimingsNV") == 0 && (!device || device_dispatch_table(device)->GetLatencyTimingsNV)) + return reinterpret_cast(vkGetLatencyTimingsNV); + if (strcmp(pName, "vkQueueNotifyOutOfBandNV") == 0 && (!device || device_dispatch_table(device)->QueueNotifyOutOfBandNV)) + return reinterpret_cast(vkQueueNotifyOutOfBandNV); + if (strcmp(pName, "vkCreateDataGraphPipelinesARM") == 0 && (!device || device_dispatch_table(device)->CreateDataGraphPipelinesARM)) + return reinterpret_cast(vkCreateDataGraphPipelinesARM); + if (strcmp(pName, "vkCreateDataGraphPipelineSessionARM") == 0 && (!device || device_dispatch_table(device)->CreateDataGraphPipelineSessionARM)) + return reinterpret_cast(vkCreateDataGraphPipelineSessionARM); + if (strcmp(pName, "vkGetDataGraphPipelineSessionBindPointRequirementsARM") == 0 && (!device || device_dispatch_table(device)->GetDataGraphPipelineSessionBindPointRequirementsARM)) + return reinterpret_cast(vkGetDataGraphPipelineSessionBindPointRequirementsARM); + if (strcmp(pName, "vkGetDataGraphPipelineSessionMemoryRequirementsARM") == 0 && (!device || device_dispatch_table(device)->GetDataGraphPipelineSessionMemoryRequirementsARM)) + return reinterpret_cast(vkGetDataGraphPipelineSessionMemoryRequirementsARM); + if (strcmp(pName, "vkBindDataGraphPipelineSessionMemoryARM") == 0 && (!device || device_dispatch_table(device)->BindDataGraphPipelineSessionMemoryARM)) + return reinterpret_cast(vkBindDataGraphPipelineSessionMemoryARM); + if (strcmp(pName, "vkDestroyDataGraphPipelineSessionARM") == 0 && (!device || device_dispatch_table(device)->DestroyDataGraphPipelineSessionARM)) + return reinterpret_cast(vkDestroyDataGraphPipelineSessionARM); + if (strcmp(pName, "vkCmdDispatchDataGraphARM") == 0 && (!device || device_dispatch_table(device)->CmdDispatchDataGraphARM)) + return reinterpret_cast(vkCmdDispatchDataGraphARM); + if (strcmp(pName, "vkGetDataGraphPipelineAvailablePropertiesARM") == 0 && (!device || device_dispatch_table(device)->GetDataGraphPipelineAvailablePropertiesARM)) + return reinterpret_cast(vkGetDataGraphPipelineAvailablePropertiesARM); + if (strcmp(pName, "vkGetDataGraphPipelinePropertiesARM") == 0 && (!device || device_dispatch_table(device)->GetDataGraphPipelinePropertiesARM)) + return reinterpret_cast(vkGetDataGraphPipelinePropertiesARM); + if (strcmp(pName, "vkCmdSetAttachmentFeedbackLoopEnableEXT") == 0 && (!device || device_dispatch_table(device)->CmdSetAttachmentFeedbackLoopEnableEXT)) + return reinterpret_cast(vkCmdSetAttachmentFeedbackLoopEnableEXT); +#if defined(VK_USE_PLATFORM_SCREEN_QNX) + if (strcmp(pName, "vkGetScreenBufferPropertiesQNX") == 0 && (!device || device_dispatch_table(device)->GetScreenBufferPropertiesQNX)) + return reinterpret_cast(vkGetScreenBufferPropertiesQNX); +#endif // VK_USE_PLATFORM_SCREEN_QNX + if (strcmp(pName, "vkCmdBindTileMemoryQCOM") == 0 && (!device || device_dispatch_table(device)->CmdBindTileMemoryQCOM)) + return reinterpret_cast(vkCmdBindTileMemoryQCOM); + if (strcmp(pName, "vkCmdDecompressMemoryEXT") == 0 && (!device || device_dispatch_table(device)->CmdDecompressMemoryEXT)) + return reinterpret_cast(vkCmdDecompressMemoryEXT); + if (strcmp(pName, "vkCmdDecompressMemoryIndirectCountEXT") == 0 && (!device || device_dispatch_table(device)->CmdDecompressMemoryIndirectCountEXT)) + return reinterpret_cast(vkCmdDecompressMemoryIndirectCountEXT); + if (strcmp(pName, "vkCreateExternalComputeQueueNV") == 0 && (!device || device_dispatch_table(device)->CreateExternalComputeQueueNV)) + return reinterpret_cast(vkCreateExternalComputeQueueNV); + if (strcmp(pName, "vkDestroyExternalComputeQueueNV") == 0 && (!device || device_dispatch_table(device)->DestroyExternalComputeQueueNV)) + return reinterpret_cast(vkDestroyExternalComputeQueueNV); + if (strcmp(pName, "vkGetExternalComputeQueueDataNV") == 0 && (!device || device_dispatch_table(device)->GetExternalComputeQueueDataNV)) + return reinterpret_cast(vkGetExternalComputeQueueDataNV); + if (strcmp(pName, "vkGetClusterAccelerationStructureBuildSizesNV") == 0 && (!device || device_dispatch_table(device)->GetClusterAccelerationStructureBuildSizesNV)) + return reinterpret_cast(vkGetClusterAccelerationStructureBuildSizesNV); + if (strcmp(pName, "vkCmdBuildClusterAccelerationStructureIndirectNV") == 0 && (!device || device_dispatch_table(device)->CmdBuildClusterAccelerationStructureIndirectNV)) + return reinterpret_cast(vkCmdBuildClusterAccelerationStructureIndirectNV); + if (strcmp(pName, "vkGetPartitionedAccelerationStructuresBuildSizesNV") == 0 && (!device || device_dispatch_table(device)->GetPartitionedAccelerationStructuresBuildSizesNV)) + return reinterpret_cast(vkGetPartitionedAccelerationStructuresBuildSizesNV); + if (strcmp(pName, "vkCmdBuildPartitionedAccelerationStructuresNV") == 0 && (!device || device_dispatch_table(device)->CmdBuildPartitionedAccelerationStructuresNV)) + return reinterpret_cast(vkCmdBuildPartitionedAccelerationStructuresNV); + if (strcmp(pName, "vkGetGeneratedCommandsMemoryRequirementsEXT") == 0 && (!device || device_dispatch_table(device)->GetGeneratedCommandsMemoryRequirementsEXT)) + return reinterpret_cast(vkGetGeneratedCommandsMemoryRequirementsEXT); + if (strcmp(pName, "vkCmdPreprocessGeneratedCommandsEXT") == 0 && (!device || device_dispatch_table(device)->CmdPreprocessGeneratedCommandsEXT)) + return reinterpret_cast(vkCmdPreprocessGeneratedCommandsEXT); + if (strcmp(pName, "vkCmdExecuteGeneratedCommandsEXT") == 0 && (!device || device_dispatch_table(device)->CmdExecuteGeneratedCommandsEXT)) + return reinterpret_cast(vkCmdExecuteGeneratedCommandsEXT); + if (strcmp(pName, "vkCreateIndirectCommandsLayoutEXT") == 0 && (!device || device_dispatch_table(device)->CreateIndirectCommandsLayoutEXT)) + return reinterpret_cast(vkCreateIndirectCommandsLayoutEXT); + if (strcmp(pName, "vkDestroyIndirectCommandsLayoutEXT") == 0 && (!device || device_dispatch_table(device)->DestroyIndirectCommandsLayoutEXT)) + return reinterpret_cast(vkDestroyIndirectCommandsLayoutEXT); + if (strcmp(pName, "vkCreateIndirectExecutionSetEXT") == 0 && (!device || device_dispatch_table(device)->CreateIndirectExecutionSetEXT)) + return reinterpret_cast(vkCreateIndirectExecutionSetEXT); + if (strcmp(pName, "vkDestroyIndirectExecutionSetEXT") == 0 && (!device || device_dispatch_table(device)->DestroyIndirectExecutionSetEXT)) + return reinterpret_cast(vkDestroyIndirectExecutionSetEXT); + if (strcmp(pName, "vkUpdateIndirectExecutionSetPipelineEXT") == 0 && (!device || device_dispatch_table(device)->UpdateIndirectExecutionSetPipelineEXT)) + return reinterpret_cast(vkUpdateIndirectExecutionSetPipelineEXT); + if (strcmp(pName, "vkUpdateIndirectExecutionSetShaderEXT") == 0 && (!device || device_dispatch_table(device)->UpdateIndirectExecutionSetShaderEXT)) + return reinterpret_cast(vkUpdateIndirectExecutionSetShaderEXT); +#if defined(VK_USE_PLATFORM_METAL_EXT) + if (strcmp(pName, "vkGetMemoryMetalHandleEXT") == 0 && (!device || device_dispatch_table(device)->GetMemoryMetalHandleEXT)) + return reinterpret_cast(vkGetMemoryMetalHandleEXT); + if (strcmp(pName, "vkGetMemoryMetalHandlePropertiesEXT") == 0 && (!device || device_dispatch_table(device)->GetMemoryMetalHandlePropertiesEXT)) + return reinterpret_cast(vkGetMemoryMetalHandlePropertiesEXT); +#endif // VK_USE_PLATFORM_METAL_EXT + if (strcmp(pName, "vkCmdEndRendering2EXT") == 0 && (!device || device_dispatch_table(device)->CmdEndRendering2EXT)) + return reinterpret_cast(vkCmdEndRendering2EXT); + if (strcmp(pName, "vkCmdBeginCustomResolveEXT") == 0 && (!device || device_dispatch_table(device)->CmdBeginCustomResolveEXT)) + return reinterpret_cast(vkCmdBeginCustomResolveEXT); + if (strcmp(pName, "vkCmdSetComputeOccupancyPriorityNV") == 0 && (!device || device_dispatch_table(device)->CmdSetComputeOccupancyPriorityNV)) + return reinterpret_cast(vkCmdSetComputeOccupancyPriorityNV); + if (strcmp(pName, "vkCreateAccelerationStructureKHR") == 0 && (!device || device_dispatch_table(device)->CreateAccelerationStructureKHR)) + return reinterpret_cast(vkCreateAccelerationStructureKHR); + if (strcmp(pName, "vkDestroyAccelerationStructureKHR") == 0 && (!device || device_dispatch_table(device)->DestroyAccelerationStructureKHR)) + return reinterpret_cast(vkDestroyAccelerationStructureKHR); + if (strcmp(pName, "vkCmdBuildAccelerationStructuresKHR") == 0 && (!device || device_dispatch_table(device)->CmdBuildAccelerationStructuresKHR)) + return reinterpret_cast(vkCmdBuildAccelerationStructuresKHR); + if (strcmp(pName, "vkCmdBuildAccelerationStructuresIndirectKHR") == 0 && (!device || device_dispatch_table(device)->CmdBuildAccelerationStructuresIndirectKHR)) + return reinterpret_cast(vkCmdBuildAccelerationStructuresIndirectKHR); + if (strcmp(pName, "vkBuildAccelerationStructuresKHR") == 0 && (!device || device_dispatch_table(device)->BuildAccelerationStructuresKHR)) + return reinterpret_cast(vkBuildAccelerationStructuresKHR); + if (strcmp(pName, "vkCopyAccelerationStructureKHR") == 0 && (!device || device_dispatch_table(device)->CopyAccelerationStructureKHR)) + return reinterpret_cast(vkCopyAccelerationStructureKHR); + if (strcmp(pName, "vkCopyAccelerationStructureToMemoryKHR") == 0 && (!device || device_dispatch_table(device)->CopyAccelerationStructureToMemoryKHR)) + return reinterpret_cast(vkCopyAccelerationStructureToMemoryKHR); + if (strcmp(pName, "vkCopyMemoryToAccelerationStructureKHR") == 0 && (!device || device_dispatch_table(device)->CopyMemoryToAccelerationStructureKHR)) + return reinterpret_cast(vkCopyMemoryToAccelerationStructureKHR); + if (strcmp(pName, "vkWriteAccelerationStructuresPropertiesKHR") == 0 && (!device || device_dispatch_table(device)->WriteAccelerationStructuresPropertiesKHR)) + return reinterpret_cast(vkWriteAccelerationStructuresPropertiesKHR); + if (strcmp(pName, "vkCmdCopyAccelerationStructureKHR") == 0 && (!device || device_dispatch_table(device)->CmdCopyAccelerationStructureKHR)) + return reinterpret_cast(vkCmdCopyAccelerationStructureKHR); + if (strcmp(pName, "vkCmdCopyAccelerationStructureToMemoryKHR") == 0 && (!device || device_dispatch_table(device)->CmdCopyAccelerationStructureToMemoryKHR)) + return reinterpret_cast(vkCmdCopyAccelerationStructureToMemoryKHR); + if (strcmp(pName, "vkCmdCopyMemoryToAccelerationStructureKHR") == 0 && (!device || device_dispatch_table(device)->CmdCopyMemoryToAccelerationStructureKHR)) + return reinterpret_cast(vkCmdCopyMemoryToAccelerationStructureKHR); + if (strcmp(pName, "vkGetAccelerationStructureDeviceAddressKHR") == 0 && (!device || device_dispatch_table(device)->GetAccelerationStructureDeviceAddressKHR)) + return reinterpret_cast(vkGetAccelerationStructureDeviceAddressKHR); + if (strcmp(pName, "vkCmdWriteAccelerationStructuresPropertiesKHR") == 0 && (!device || device_dispatch_table(device)->CmdWriteAccelerationStructuresPropertiesKHR)) + return reinterpret_cast(vkCmdWriteAccelerationStructuresPropertiesKHR); + if (strcmp(pName, "vkGetDeviceAccelerationStructureCompatibilityKHR") == 0 && (!device || device_dispatch_table(device)->GetDeviceAccelerationStructureCompatibilityKHR)) + return reinterpret_cast(vkGetDeviceAccelerationStructureCompatibilityKHR); + if (strcmp(pName, "vkGetAccelerationStructureBuildSizesKHR") == 0 && (!device || device_dispatch_table(device)->GetAccelerationStructureBuildSizesKHR)) + return reinterpret_cast(vkGetAccelerationStructureBuildSizesKHR); + if (strcmp(pName, "vkCmdTraceRaysKHR") == 0 && (!device || device_dispatch_table(device)->CmdTraceRaysKHR)) + return reinterpret_cast(vkCmdTraceRaysKHR); + if (strcmp(pName, "vkCreateRayTracingPipelinesKHR") == 0 && (!device || device_dispatch_table(device)->CreateRayTracingPipelinesKHR)) + return reinterpret_cast(vkCreateRayTracingPipelinesKHR); + if (strcmp(pName, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR") == 0 && (!device || device_dispatch_table(device)->GetRayTracingCaptureReplayShaderGroupHandlesKHR)) + return reinterpret_cast(vkGetRayTracingCaptureReplayShaderGroupHandlesKHR); + if (strcmp(pName, "vkCmdTraceRaysIndirectKHR") == 0 && (!device || device_dispatch_table(device)->CmdTraceRaysIndirectKHR)) + return reinterpret_cast(vkCmdTraceRaysIndirectKHR); + if (strcmp(pName, "vkGetRayTracingShaderGroupStackSizeKHR") == 0 && (!device || device_dispatch_table(device)->GetRayTracingShaderGroupStackSizeKHR)) + return reinterpret_cast(vkGetRayTracingShaderGroupStackSizeKHR); + if (strcmp(pName, "vkCmdSetRayTracingPipelineStackSizeKHR") == 0 && (!device || device_dispatch_table(device)->CmdSetRayTracingPipelineStackSizeKHR)) + return reinterpret_cast(vkCmdSetRayTracingPipelineStackSizeKHR); + if (strcmp(pName, "vkCmdDrawMeshTasksEXT") == 0 && (!device || device_dispatch_table(device)->CmdDrawMeshTasksEXT)) + return reinterpret_cast(vkCmdDrawMeshTasksEXT); + if (strcmp(pName, "vkCmdDrawMeshTasksIndirectEXT") == 0 && (!device || device_dispatch_table(device)->CmdDrawMeshTasksIndirectEXT)) + return reinterpret_cast(vkCmdDrawMeshTasksIndirectEXT); + if (strcmp(pName, "vkCmdDrawMeshTasksIndirectCountEXT") == 0 && (!device || device_dispatch_table(device)->CmdDrawMeshTasksIndirectCountEXT)) + return reinterpret_cast(vkCmdDrawMeshTasksIndirectCountEXT); + + return nullptr; +} diff --git a/layersvt/generated/cputiming_implementation.h b/layersvt/generated/cputiming_implementation.h new file mode 100644 index 0000000000..938889861d --- /dev/null +++ b/layersvt/generated/cputiming_implementation.h @@ -0,0 +1,64943 @@ + +/* Copyright (c) 2015-2026 Valve Corporation + * Copyright (c) 2015-2026 LunarG, Inc. + * Copyright (c) 2015-2017, 2019, 2021 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +/* + * This file is generated from the Khronos Vulkan XML API Registry. + */ + +#pragma once + +#include "api_dump.h" + +//========================== Handle Implementations =========================// + +template +void dump_VkBuffer(const VkBuffer& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkImage(const VkImage& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkInstance(const VkInstance& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(static_cast(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkPhysicalDevice(const VkPhysicalDevice& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(static_cast(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkDevice(const VkDevice& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(static_cast(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkQueue(const VkQueue& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(static_cast(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkSemaphore(const VkSemaphore& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkCommandBuffer(const VkCommandBuffer& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(static_cast(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkFence(const VkFence& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkDeviceMemory(const VkDeviceMemory& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkQueryPool(const VkQueryPool& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkImageView(const VkImageView& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkCommandPool(const VkCommandPool& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkRenderPass(const VkRenderPass& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkFramebuffer(const VkFramebuffer& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkEvent(const VkEvent& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkBufferView(const VkBufferView& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkShaderModule(const VkShaderModule& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkPipelineCache(const VkPipelineCache& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkPipelineLayout(const VkPipelineLayout& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkPipeline(const VkPipeline& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkDescriptorSetLayout(const VkDescriptorSetLayout& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkSampler(const VkSampler& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkDescriptorSet(const VkDescriptorSet& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkDescriptorPool(const VkDescriptorPool& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkDescriptorUpdateTemplate(const VkDescriptorUpdateTemplate& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkSamplerYcbcrConversion(const VkSamplerYcbcrConversion& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkPrivateDataSlot(const VkPrivateDataSlot& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkSurfaceKHR(const VkSurfaceKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkSwapchainKHR(const VkSwapchainKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkDisplayKHR(const VkDisplayKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkDisplayModeKHR(const VkDisplayModeKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkVideoSessionKHR(const VkVideoSessionKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkVideoSessionParametersKHR(const VkVideoSessionParametersKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkDeferredOperationKHR(const VkDeferredOperationKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkPipelineBinaryKHR(const VkPipelineBinaryKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkDebugReportCallbackEXT(const VkDebugReportCallbackEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkCuModuleNVX(const VkCuModuleNVX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkCuFunctionNVX(const VkCuFunctionNVX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkDebugUtilsMessengerEXT(const VkDebugUtilsMessengerEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkTensorARM(const VkTensorARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkValidationCacheEXT(const VkValidationCacheEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkAccelerationStructureNV(const VkAccelerationStructureNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkPerformanceConfigurationINTEL(const VkPerformanceConfigurationINTEL& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkIndirectCommandsLayoutNV(const VkIndirectCommandsLayoutNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} +#if defined(VK_ENABLE_BETA_EXTENSIONS) + +template +void dump_VkCudaModuleNV(const VkCudaModuleNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkCudaFunctionNV(const VkCudaFunctionNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} +#endif // VK_ENABLE_BETA_EXTENSIONS + +template +void dump_VkAccelerationStructureKHR(const VkAccelerationStructureKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} +#if defined(VK_USE_PLATFORM_FUCHSIA) + +template +void dump_VkBufferCollectionFUCHSIA(const VkBufferCollectionFUCHSIA& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} +#endif // VK_USE_PLATFORM_FUCHSIA + +template +void dump_VkMicromapEXT(const VkMicromapEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkTensorViewARM(const VkTensorViewARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkOpticalFlowSessionNV(const VkOpticalFlowSessionNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkShaderEXT(const VkShaderEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkDataGraphPipelineSessionARM(const VkDataGraphPipelineSessionARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkExternalComputeQueueNV(const VkExternalComputeQueueNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(static_cast(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkIndirectExecutionSetEXT(const VkIndirectExecutionSetEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +template +void dump_VkIndirectCommandsLayoutEXT(const VkIndirectCommandsLayoutEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_handle(TYPE_ERASE_HANDLE(object), settings, type_name, var_name, indents, address); +} + +//======================== Video Enum Implementations =======================// + +template +void dump_StdVideoH264ChromaFormatIdc(const StdVideoH264ChromaFormatIdc object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME: + dump_enum(settings, "STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME", static_cast(object)); + break; + case STD_VIDEO_H264_CHROMA_FORMAT_IDC_420: + dump_enum(settings, "STD_VIDEO_H264_CHROMA_FORMAT_IDC_420", static_cast(object)); + break; + case STD_VIDEO_H264_CHROMA_FORMAT_IDC_422: + dump_enum(settings, "STD_VIDEO_H264_CHROMA_FORMAT_IDC_422", static_cast(object)); + break; + case STD_VIDEO_H264_CHROMA_FORMAT_IDC_444: + dump_enum(settings, "STD_VIDEO_H264_CHROMA_FORMAT_IDC_444", static_cast(object)); + break; + case STD_VIDEO_H264_CHROMA_FORMAT_IDC_INVALID: + dump_enum(settings, "STD_VIDEO_H264_CHROMA_FORMAT_IDC_INVALID", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_StdVideoH264ProfileIdc(const StdVideoH264ProfileIdc object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case STD_VIDEO_H264_PROFILE_IDC_BASELINE: + dump_enum(settings, "STD_VIDEO_H264_PROFILE_IDC_BASELINE", static_cast(object)); + break; + case STD_VIDEO_H264_PROFILE_IDC_MAIN: + dump_enum(settings, "STD_VIDEO_H264_PROFILE_IDC_MAIN", static_cast(object)); + break; + case STD_VIDEO_H264_PROFILE_IDC_HIGH: + dump_enum(settings, "STD_VIDEO_H264_PROFILE_IDC_HIGH", static_cast(object)); + break; + case STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE: + dump_enum(settings, "STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE", static_cast(object)); + break; + case STD_VIDEO_H264_PROFILE_IDC_INVALID: + dump_enum(settings, "STD_VIDEO_H264_PROFILE_IDC_INVALID", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_StdVideoH264LevelIdc(const StdVideoH264LevelIdc object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case STD_VIDEO_H264_LEVEL_IDC_1_0: + dump_enum(settings, "STD_VIDEO_H264_LEVEL_IDC_1_0", static_cast(object)); + break; + case STD_VIDEO_H264_LEVEL_IDC_1_1: + dump_enum(settings, "STD_VIDEO_H264_LEVEL_IDC_1_1", static_cast(object)); + break; + case STD_VIDEO_H264_LEVEL_IDC_1_2: + dump_enum(settings, "STD_VIDEO_H264_LEVEL_IDC_1_2", static_cast(object)); + break; + case STD_VIDEO_H264_LEVEL_IDC_1_3: + dump_enum(settings, "STD_VIDEO_H264_LEVEL_IDC_1_3", static_cast(object)); + break; + case STD_VIDEO_H264_LEVEL_IDC_2_0: + dump_enum(settings, "STD_VIDEO_H264_LEVEL_IDC_2_0", static_cast(object)); + break; + case STD_VIDEO_H264_LEVEL_IDC_2_1: + dump_enum(settings, "STD_VIDEO_H264_LEVEL_IDC_2_1", static_cast(object)); + break; + case STD_VIDEO_H264_LEVEL_IDC_2_2: + dump_enum(settings, "STD_VIDEO_H264_LEVEL_IDC_2_2", static_cast(object)); + break; + case STD_VIDEO_H264_LEVEL_IDC_3_0: + dump_enum(settings, "STD_VIDEO_H264_LEVEL_IDC_3_0", static_cast(object)); + break; + case STD_VIDEO_H264_LEVEL_IDC_3_1: + dump_enum(settings, "STD_VIDEO_H264_LEVEL_IDC_3_1", static_cast(object)); + break; + case STD_VIDEO_H264_LEVEL_IDC_3_2: + dump_enum(settings, "STD_VIDEO_H264_LEVEL_IDC_3_2", static_cast(object)); + break; + case STD_VIDEO_H264_LEVEL_IDC_4_0: + dump_enum(settings, "STD_VIDEO_H264_LEVEL_IDC_4_0", static_cast(object)); + break; + case STD_VIDEO_H264_LEVEL_IDC_4_1: + dump_enum(settings, "STD_VIDEO_H264_LEVEL_IDC_4_1", static_cast(object)); + break; + case STD_VIDEO_H264_LEVEL_IDC_4_2: + dump_enum(settings, "STD_VIDEO_H264_LEVEL_IDC_4_2", static_cast(object)); + break; + case STD_VIDEO_H264_LEVEL_IDC_5_0: + dump_enum(settings, "STD_VIDEO_H264_LEVEL_IDC_5_0", static_cast(object)); + break; + case STD_VIDEO_H264_LEVEL_IDC_5_1: + dump_enum(settings, "STD_VIDEO_H264_LEVEL_IDC_5_1", static_cast(object)); + break; + case STD_VIDEO_H264_LEVEL_IDC_5_2: + dump_enum(settings, "STD_VIDEO_H264_LEVEL_IDC_5_2", static_cast(object)); + break; + case STD_VIDEO_H264_LEVEL_IDC_6_0: + dump_enum(settings, "STD_VIDEO_H264_LEVEL_IDC_6_0", static_cast(object)); + break; + case STD_VIDEO_H264_LEVEL_IDC_6_1: + dump_enum(settings, "STD_VIDEO_H264_LEVEL_IDC_6_1", static_cast(object)); + break; + case STD_VIDEO_H264_LEVEL_IDC_6_2: + dump_enum(settings, "STD_VIDEO_H264_LEVEL_IDC_6_2", static_cast(object)); + break; + case STD_VIDEO_H264_LEVEL_IDC_INVALID: + dump_enum(settings, "STD_VIDEO_H264_LEVEL_IDC_INVALID", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_StdVideoH264PocType(const StdVideoH264PocType object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case STD_VIDEO_H264_POC_TYPE_0: + dump_enum(settings, "STD_VIDEO_H264_POC_TYPE_0", static_cast(object)); + break; + case STD_VIDEO_H264_POC_TYPE_1: + dump_enum(settings, "STD_VIDEO_H264_POC_TYPE_1", static_cast(object)); + break; + case STD_VIDEO_H264_POC_TYPE_2: + dump_enum(settings, "STD_VIDEO_H264_POC_TYPE_2", static_cast(object)); + break; + case STD_VIDEO_H264_POC_TYPE_INVALID: + dump_enum(settings, "STD_VIDEO_H264_POC_TYPE_INVALID", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_StdVideoH264AspectRatioIdc(const StdVideoH264AspectRatioIdc object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case STD_VIDEO_H264_ASPECT_RATIO_IDC_UNSPECIFIED: + dump_enum(settings, "STD_VIDEO_H264_ASPECT_RATIO_IDC_UNSPECIFIED", static_cast(object)); + break; + case STD_VIDEO_H264_ASPECT_RATIO_IDC_SQUARE: + dump_enum(settings, "STD_VIDEO_H264_ASPECT_RATIO_IDC_SQUARE", static_cast(object)); + break; + case STD_VIDEO_H264_ASPECT_RATIO_IDC_12_11: + dump_enum(settings, "STD_VIDEO_H264_ASPECT_RATIO_IDC_12_11", static_cast(object)); + break; + case STD_VIDEO_H264_ASPECT_RATIO_IDC_10_11: + dump_enum(settings, "STD_VIDEO_H264_ASPECT_RATIO_IDC_10_11", static_cast(object)); + break; + case STD_VIDEO_H264_ASPECT_RATIO_IDC_16_11: + dump_enum(settings, "STD_VIDEO_H264_ASPECT_RATIO_IDC_16_11", static_cast(object)); + break; + case STD_VIDEO_H264_ASPECT_RATIO_IDC_40_33: + dump_enum(settings, "STD_VIDEO_H264_ASPECT_RATIO_IDC_40_33", static_cast(object)); + break; + case STD_VIDEO_H264_ASPECT_RATIO_IDC_24_11: + dump_enum(settings, "STD_VIDEO_H264_ASPECT_RATIO_IDC_24_11", static_cast(object)); + break; + case STD_VIDEO_H264_ASPECT_RATIO_IDC_20_11: + dump_enum(settings, "STD_VIDEO_H264_ASPECT_RATIO_IDC_20_11", static_cast(object)); + break; + case STD_VIDEO_H264_ASPECT_RATIO_IDC_32_11: + dump_enum(settings, "STD_VIDEO_H264_ASPECT_RATIO_IDC_32_11", static_cast(object)); + break; + case STD_VIDEO_H264_ASPECT_RATIO_IDC_80_33: + dump_enum(settings, "STD_VIDEO_H264_ASPECT_RATIO_IDC_80_33", static_cast(object)); + break; + case STD_VIDEO_H264_ASPECT_RATIO_IDC_18_11: + dump_enum(settings, "STD_VIDEO_H264_ASPECT_RATIO_IDC_18_11", static_cast(object)); + break; + case STD_VIDEO_H264_ASPECT_RATIO_IDC_15_11: + dump_enum(settings, "STD_VIDEO_H264_ASPECT_RATIO_IDC_15_11", static_cast(object)); + break; + case STD_VIDEO_H264_ASPECT_RATIO_IDC_64_33: + dump_enum(settings, "STD_VIDEO_H264_ASPECT_RATIO_IDC_64_33", static_cast(object)); + break; + case STD_VIDEO_H264_ASPECT_RATIO_IDC_160_99: + dump_enum(settings, "STD_VIDEO_H264_ASPECT_RATIO_IDC_160_99", static_cast(object)); + break; + case STD_VIDEO_H264_ASPECT_RATIO_IDC_4_3: + dump_enum(settings, "STD_VIDEO_H264_ASPECT_RATIO_IDC_4_3", static_cast(object)); + break; + case STD_VIDEO_H264_ASPECT_RATIO_IDC_3_2: + dump_enum(settings, "STD_VIDEO_H264_ASPECT_RATIO_IDC_3_2", static_cast(object)); + break; + case STD_VIDEO_H264_ASPECT_RATIO_IDC_2_1: + dump_enum(settings, "STD_VIDEO_H264_ASPECT_RATIO_IDC_2_1", static_cast(object)); + break; + case STD_VIDEO_H264_ASPECT_RATIO_IDC_EXTENDED_SAR: + dump_enum(settings, "STD_VIDEO_H264_ASPECT_RATIO_IDC_EXTENDED_SAR", static_cast(object)); + break; + case STD_VIDEO_H264_ASPECT_RATIO_IDC_INVALID: + dump_enum(settings, "STD_VIDEO_H264_ASPECT_RATIO_IDC_INVALID", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_StdVideoH264WeightedBipredIdc(const StdVideoH264WeightedBipredIdc object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_DEFAULT: + dump_enum(settings, "STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_DEFAULT", static_cast(object)); + break; + case STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_EXPLICIT: + dump_enum(settings, "STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_EXPLICIT", static_cast(object)); + break; + case STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_IMPLICIT: + dump_enum(settings, "STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_IMPLICIT", static_cast(object)); + break; + case STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_INVALID: + dump_enum(settings, "STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_INVALID", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_StdVideoH264ModificationOfPicNumsIdc(const StdVideoH264ModificationOfPicNumsIdc object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_SUBTRACT: + dump_enum(settings, "STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_SUBTRACT", static_cast(object)); + break; + case STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_ADD: + dump_enum(settings, "STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_ADD", static_cast(object)); + break; + case STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_LONG_TERM: + dump_enum(settings, "STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_LONG_TERM", static_cast(object)); + break; + case STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_END: + dump_enum(settings, "STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_END", static_cast(object)); + break; + case STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_INVALID: + dump_enum(settings, "STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_INVALID", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_StdVideoH264MemMgmtControlOp(const StdVideoH264MemMgmtControlOp object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_END: + dump_enum(settings, "STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_END", static_cast(object)); + break; + case STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_SHORT_TERM: + dump_enum(settings, "STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_SHORT_TERM", static_cast(object)); + break; + case STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_LONG_TERM: + dump_enum(settings, "STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_LONG_TERM", static_cast(object)); + break; + case STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_LONG_TERM: + dump_enum(settings, "STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_LONG_TERM", static_cast(object)); + break; + case STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_SET_MAX_LONG_TERM_INDEX: + dump_enum(settings, "STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_SET_MAX_LONG_TERM_INDEX", static_cast(object)); + break; + case STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_ALL: + dump_enum(settings, "STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_ALL", static_cast(object)); + break; + case STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_CURRENT_AS_LONG_TERM: + dump_enum(settings, "STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_CURRENT_AS_LONG_TERM", static_cast(object)); + break; + case STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_INVALID: + dump_enum(settings, "STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_INVALID", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_StdVideoH264CabacInitIdc(const StdVideoH264CabacInitIdc object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case STD_VIDEO_H264_CABAC_INIT_IDC_0: + dump_enum(settings, "STD_VIDEO_H264_CABAC_INIT_IDC_0", static_cast(object)); + break; + case STD_VIDEO_H264_CABAC_INIT_IDC_1: + dump_enum(settings, "STD_VIDEO_H264_CABAC_INIT_IDC_1", static_cast(object)); + break; + case STD_VIDEO_H264_CABAC_INIT_IDC_2: + dump_enum(settings, "STD_VIDEO_H264_CABAC_INIT_IDC_2", static_cast(object)); + break; + case STD_VIDEO_H264_CABAC_INIT_IDC_INVALID: + dump_enum(settings, "STD_VIDEO_H264_CABAC_INIT_IDC_INVALID", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_StdVideoH264DisableDeblockingFilterIdc(const StdVideoH264DisableDeblockingFilterIdc object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_DISABLED: + dump_enum(settings, "STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_DISABLED", static_cast(object)); + break; + case STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_ENABLED: + dump_enum(settings, "STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_ENABLED", static_cast(object)); + break; + case STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_PARTIAL: + dump_enum(settings, "STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_PARTIAL", static_cast(object)); + break; + case STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_INVALID: + dump_enum(settings, "STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_INVALID", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_StdVideoH264SliceType(const StdVideoH264SliceType object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case STD_VIDEO_H264_SLICE_TYPE_P: + dump_enum(settings, "STD_VIDEO_H264_SLICE_TYPE_P", static_cast(object)); + break; + case STD_VIDEO_H264_SLICE_TYPE_B: + dump_enum(settings, "STD_VIDEO_H264_SLICE_TYPE_B", static_cast(object)); + break; + case STD_VIDEO_H264_SLICE_TYPE_I: + dump_enum(settings, "STD_VIDEO_H264_SLICE_TYPE_I", static_cast(object)); + break; + case STD_VIDEO_H264_SLICE_TYPE_INVALID: + dump_enum(settings, "STD_VIDEO_H264_SLICE_TYPE_INVALID", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_StdVideoH264PictureType(const StdVideoH264PictureType object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case STD_VIDEO_H264_PICTURE_TYPE_P: + dump_enum(settings, "STD_VIDEO_H264_PICTURE_TYPE_P", static_cast(object)); + break; + case STD_VIDEO_H264_PICTURE_TYPE_B: + dump_enum(settings, "STD_VIDEO_H264_PICTURE_TYPE_B", static_cast(object)); + break; + case STD_VIDEO_H264_PICTURE_TYPE_I: + dump_enum(settings, "STD_VIDEO_H264_PICTURE_TYPE_I", static_cast(object)); + break; + case STD_VIDEO_H264_PICTURE_TYPE_IDR: + dump_enum(settings, "STD_VIDEO_H264_PICTURE_TYPE_IDR", static_cast(object)); + break; + case STD_VIDEO_H264_PICTURE_TYPE_INVALID: + dump_enum(settings, "STD_VIDEO_H264_PICTURE_TYPE_INVALID", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_StdVideoH264NonVclNaluType(const StdVideoH264NonVclNaluType object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case STD_VIDEO_H264_NON_VCL_NALU_TYPE_SPS: + dump_enum(settings, "STD_VIDEO_H264_NON_VCL_NALU_TYPE_SPS", static_cast(object)); + break; + case STD_VIDEO_H264_NON_VCL_NALU_TYPE_PPS: + dump_enum(settings, "STD_VIDEO_H264_NON_VCL_NALU_TYPE_PPS", static_cast(object)); + break; + case STD_VIDEO_H264_NON_VCL_NALU_TYPE_AUD: + dump_enum(settings, "STD_VIDEO_H264_NON_VCL_NALU_TYPE_AUD", static_cast(object)); + break; + case STD_VIDEO_H264_NON_VCL_NALU_TYPE_PREFIX: + dump_enum(settings, "STD_VIDEO_H264_NON_VCL_NALU_TYPE_PREFIX", static_cast(object)); + break; + case STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_SEQUENCE: + dump_enum(settings, "STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_SEQUENCE", static_cast(object)); + break; + case STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_STREAM: + dump_enum(settings, "STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_STREAM", static_cast(object)); + break; + case STD_VIDEO_H264_NON_VCL_NALU_TYPE_PRECODED: + dump_enum(settings, "STD_VIDEO_H264_NON_VCL_NALU_TYPE_PRECODED", static_cast(object)); + break; + case STD_VIDEO_H264_NON_VCL_NALU_TYPE_INVALID: + dump_enum(settings, "STD_VIDEO_H264_NON_VCL_NALU_TYPE_INVALID", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_StdVideoDecodeH264FieldOrderCount(const StdVideoDecodeH264FieldOrderCount object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_TOP: + dump_enum(settings, "STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_TOP", static_cast(object)); + break; + case STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_BOTTOM: + dump_enum(settings, "STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_BOTTOM", static_cast(object)); + break; + case STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_INVALID: + dump_enum(settings, "STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_INVALID", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_StdVideoH265ChromaFormatIdc(const StdVideoH265ChromaFormatIdc object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME: + dump_enum(settings, "STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME", static_cast(object)); + break; + case STD_VIDEO_H265_CHROMA_FORMAT_IDC_420: + dump_enum(settings, "STD_VIDEO_H265_CHROMA_FORMAT_IDC_420", static_cast(object)); + break; + case STD_VIDEO_H265_CHROMA_FORMAT_IDC_422: + dump_enum(settings, "STD_VIDEO_H265_CHROMA_FORMAT_IDC_422", static_cast(object)); + break; + case STD_VIDEO_H265_CHROMA_FORMAT_IDC_444: + dump_enum(settings, "STD_VIDEO_H265_CHROMA_FORMAT_IDC_444", static_cast(object)); + break; + case STD_VIDEO_H265_CHROMA_FORMAT_IDC_INVALID: + dump_enum(settings, "STD_VIDEO_H265_CHROMA_FORMAT_IDC_INVALID", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_StdVideoH265ProfileIdc(const StdVideoH265ProfileIdc object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case STD_VIDEO_H265_PROFILE_IDC_MAIN: + dump_enum(settings, "STD_VIDEO_H265_PROFILE_IDC_MAIN", static_cast(object)); + break; + case STD_VIDEO_H265_PROFILE_IDC_MAIN_10: + dump_enum(settings, "STD_VIDEO_H265_PROFILE_IDC_MAIN_10", static_cast(object)); + break; + case STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE: + dump_enum(settings, "STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE", static_cast(object)); + break; + case STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS: + dump_enum(settings, "STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS", static_cast(object)); + break; + case STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS: + dump_enum(settings, "STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS", static_cast(object)); + break; + case STD_VIDEO_H265_PROFILE_IDC_INVALID: + dump_enum(settings, "STD_VIDEO_H265_PROFILE_IDC_INVALID", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_StdVideoH265LevelIdc(const StdVideoH265LevelIdc object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case STD_VIDEO_H265_LEVEL_IDC_1_0: + dump_enum(settings, "STD_VIDEO_H265_LEVEL_IDC_1_0", static_cast(object)); + break; + case STD_VIDEO_H265_LEVEL_IDC_2_0: + dump_enum(settings, "STD_VIDEO_H265_LEVEL_IDC_2_0", static_cast(object)); + break; + case STD_VIDEO_H265_LEVEL_IDC_2_1: + dump_enum(settings, "STD_VIDEO_H265_LEVEL_IDC_2_1", static_cast(object)); + break; + case STD_VIDEO_H265_LEVEL_IDC_3_0: + dump_enum(settings, "STD_VIDEO_H265_LEVEL_IDC_3_0", static_cast(object)); + break; + case STD_VIDEO_H265_LEVEL_IDC_3_1: + dump_enum(settings, "STD_VIDEO_H265_LEVEL_IDC_3_1", static_cast(object)); + break; + case STD_VIDEO_H265_LEVEL_IDC_4_0: + dump_enum(settings, "STD_VIDEO_H265_LEVEL_IDC_4_0", static_cast(object)); + break; + case STD_VIDEO_H265_LEVEL_IDC_4_1: + dump_enum(settings, "STD_VIDEO_H265_LEVEL_IDC_4_1", static_cast(object)); + break; + case STD_VIDEO_H265_LEVEL_IDC_5_0: + dump_enum(settings, "STD_VIDEO_H265_LEVEL_IDC_5_0", static_cast(object)); + break; + case STD_VIDEO_H265_LEVEL_IDC_5_1: + dump_enum(settings, "STD_VIDEO_H265_LEVEL_IDC_5_1", static_cast(object)); + break; + case STD_VIDEO_H265_LEVEL_IDC_5_2: + dump_enum(settings, "STD_VIDEO_H265_LEVEL_IDC_5_2", static_cast(object)); + break; + case STD_VIDEO_H265_LEVEL_IDC_6_0: + dump_enum(settings, "STD_VIDEO_H265_LEVEL_IDC_6_0", static_cast(object)); + break; + case STD_VIDEO_H265_LEVEL_IDC_6_1: + dump_enum(settings, "STD_VIDEO_H265_LEVEL_IDC_6_1", static_cast(object)); + break; + case STD_VIDEO_H265_LEVEL_IDC_6_2: + dump_enum(settings, "STD_VIDEO_H265_LEVEL_IDC_6_2", static_cast(object)); + break; + case STD_VIDEO_H265_LEVEL_IDC_INVALID: + dump_enum(settings, "STD_VIDEO_H265_LEVEL_IDC_INVALID", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_StdVideoH265SliceType(const StdVideoH265SliceType object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case STD_VIDEO_H265_SLICE_TYPE_B: + dump_enum(settings, "STD_VIDEO_H265_SLICE_TYPE_B", static_cast(object)); + break; + case STD_VIDEO_H265_SLICE_TYPE_P: + dump_enum(settings, "STD_VIDEO_H265_SLICE_TYPE_P", static_cast(object)); + break; + case STD_VIDEO_H265_SLICE_TYPE_I: + dump_enum(settings, "STD_VIDEO_H265_SLICE_TYPE_I", static_cast(object)); + break; + case STD_VIDEO_H265_SLICE_TYPE_INVALID: + dump_enum(settings, "STD_VIDEO_H265_SLICE_TYPE_INVALID", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_StdVideoH265PictureType(const StdVideoH265PictureType object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case STD_VIDEO_H265_PICTURE_TYPE_P: + dump_enum(settings, "STD_VIDEO_H265_PICTURE_TYPE_P", static_cast(object)); + break; + case STD_VIDEO_H265_PICTURE_TYPE_B: + dump_enum(settings, "STD_VIDEO_H265_PICTURE_TYPE_B", static_cast(object)); + break; + case STD_VIDEO_H265_PICTURE_TYPE_I: + dump_enum(settings, "STD_VIDEO_H265_PICTURE_TYPE_I", static_cast(object)); + break; + case STD_VIDEO_H265_PICTURE_TYPE_IDR: + dump_enum(settings, "STD_VIDEO_H265_PICTURE_TYPE_IDR", static_cast(object)); + break; + case STD_VIDEO_H265_PICTURE_TYPE_INVALID: + dump_enum(settings, "STD_VIDEO_H265_PICTURE_TYPE_INVALID", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_StdVideoH265AspectRatioIdc(const StdVideoH265AspectRatioIdc object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case STD_VIDEO_H265_ASPECT_RATIO_IDC_UNSPECIFIED: + dump_enum(settings, "STD_VIDEO_H265_ASPECT_RATIO_IDC_UNSPECIFIED", static_cast(object)); + break; + case STD_VIDEO_H265_ASPECT_RATIO_IDC_SQUARE: + dump_enum(settings, "STD_VIDEO_H265_ASPECT_RATIO_IDC_SQUARE", static_cast(object)); + break; + case STD_VIDEO_H265_ASPECT_RATIO_IDC_12_11: + dump_enum(settings, "STD_VIDEO_H265_ASPECT_RATIO_IDC_12_11", static_cast(object)); + break; + case STD_VIDEO_H265_ASPECT_RATIO_IDC_10_11: + dump_enum(settings, "STD_VIDEO_H265_ASPECT_RATIO_IDC_10_11", static_cast(object)); + break; + case STD_VIDEO_H265_ASPECT_RATIO_IDC_16_11: + dump_enum(settings, "STD_VIDEO_H265_ASPECT_RATIO_IDC_16_11", static_cast(object)); + break; + case STD_VIDEO_H265_ASPECT_RATIO_IDC_40_33: + dump_enum(settings, "STD_VIDEO_H265_ASPECT_RATIO_IDC_40_33", static_cast(object)); + break; + case STD_VIDEO_H265_ASPECT_RATIO_IDC_24_11: + dump_enum(settings, "STD_VIDEO_H265_ASPECT_RATIO_IDC_24_11", static_cast(object)); + break; + case STD_VIDEO_H265_ASPECT_RATIO_IDC_20_11: + dump_enum(settings, "STD_VIDEO_H265_ASPECT_RATIO_IDC_20_11", static_cast(object)); + break; + case STD_VIDEO_H265_ASPECT_RATIO_IDC_32_11: + dump_enum(settings, "STD_VIDEO_H265_ASPECT_RATIO_IDC_32_11", static_cast(object)); + break; + case STD_VIDEO_H265_ASPECT_RATIO_IDC_80_33: + dump_enum(settings, "STD_VIDEO_H265_ASPECT_RATIO_IDC_80_33", static_cast(object)); + break; + case STD_VIDEO_H265_ASPECT_RATIO_IDC_18_11: + dump_enum(settings, "STD_VIDEO_H265_ASPECT_RATIO_IDC_18_11", static_cast(object)); + break; + case STD_VIDEO_H265_ASPECT_RATIO_IDC_15_11: + dump_enum(settings, "STD_VIDEO_H265_ASPECT_RATIO_IDC_15_11", static_cast(object)); + break; + case STD_VIDEO_H265_ASPECT_RATIO_IDC_64_33: + dump_enum(settings, "STD_VIDEO_H265_ASPECT_RATIO_IDC_64_33", static_cast(object)); + break; + case STD_VIDEO_H265_ASPECT_RATIO_IDC_160_99: + dump_enum(settings, "STD_VIDEO_H265_ASPECT_RATIO_IDC_160_99", static_cast(object)); + break; + case STD_VIDEO_H265_ASPECT_RATIO_IDC_4_3: + dump_enum(settings, "STD_VIDEO_H265_ASPECT_RATIO_IDC_4_3", static_cast(object)); + break; + case STD_VIDEO_H265_ASPECT_RATIO_IDC_3_2: + dump_enum(settings, "STD_VIDEO_H265_ASPECT_RATIO_IDC_3_2", static_cast(object)); + break; + case STD_VIDEO_H265_ASPECT_RATIO_IDC_2_1: + dump_enum(settings, "STD_VIDEO_H265_ASPECT_RATIO_IDC_2_1", static_cast(object)); + break; + case STD_VIDEO_H265_ASPECT_RATIO_IDC_EXTENDED_SAR: + dump_enum(settings, "STD_VIDEO_H265_ASPECT_RATIO_IDC_EXTENDED_SAR", static_cast(object)); + break; + case STD_VIDEO_H265_ASPECT_RATIO_IDC_INVALID: + dump_enum(settings, "STD_VIDEO_H265_ASPECT_RATIO_IDC_INVALID", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_StdVideoAV1Profile(const StdVideoAV1Profile object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case STD_VIDEO_AV1_PROFILE_MAIN: + dump_enum(settings, "STD_VIDEO_AV1_PROFILE_MAIN", static_cast(object)); + break; + case STD_VIDEO_AV1_PROFILE_HIGH: + dump_enum(settings, "STD_VIDEO_AV1_PROFILE_HIGH", static_cast(object)); + break; + case STD_VIDEO_AV1_PROFILE_PROFESSIONAL: + dump_enum(settings, "STD_VIDEO_AV1_PROFILE_PROFESSIONAL", static_cast(object)); + break; + case STD_VIDEO_AV1_PROFILE_INVALID: + dump_enum(settings, "STD_VIDEO_AV1_PROFILE_INVALID", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_StdVideoAV1Level(const StdVideoAV1Level object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case STD_VIDEO_AV1_LEVEL_2_0: + dump_enum(settings, "STD_VIDEO_AV1_LEVEL_2_0", static_cast(object)); + break; + case STD_VIDEO_AV1_LEVEL_2_1: + dump_enum(settings, "STD_VIDEO_AV1_LEVEL_2_1", static_cast(object)); + break; + case STD_VIDEO_AV1_LEVEL_2_2: + dump_enum(settings, "STD_VIDEO_AV1_LEVEL_2_2", static_cast(object)); + break; + case STD_VIDEO_AV1_LEVEL_2_3: + dump_enum(settings, "STD_VIDEO_AV1_LEVEL_2_3", static_cast(object)); + break; + case STD_VIDEO_AV1_LEVEL_3_0: + dump_enum(settings, "STD_VIDEO_AV1_LEVEL_3_0", static_cast(object)); + break; + case STD_VIDEO_AV1_LEVEL_3_1: + dump_enum(settings, "STD_VIDEO_AV1_LEVEL_3_1", static_cast(object)); + break; + case STD_VIDEO_AV1_LEVEL_3_2: + dump_enum(settings, "STD_VIDEO_AV1_LEVEL_3_2", static_cast(object)); + break; + case STD_VIDEO_AV1_LEVEL_3_3: + dump_enum(settings, "STD_VIDEO_AV1_LEVEL_3_3", static_cast(object)); + break; + case STD_VIDEO_AV1_LEVEL_4_0: + dump_enum(settings, "STD_VIDEO_AV1_LEVEL_4_0", static_cast(object)); + break; + case STD_VIDEO_AV1_LEVEL_4_1: + dump_enum(settings, "STD_VIDEO_AV1_LEVEL_4_1", static_cast(object)); + break; + case STD_VIDEO_AV1_LEVEL_4_2: + dump_enum(settings, "STD_VIDEO_AV1_LEVEL_4_2", static_cast(object)); + break; + case STD_VIDEO_AV1_LEVEL_4_3: + dump_enum(settings, "STD_VIDEO_AV1_LEVEL_4_3", static_cast(object)); + break; + case STD_VIDEO_AV1_LEVEL_5_0: + dump_enum(settings, "STD_VIDEO_AV1_LEVEL_5_0", static_cast(object)); + break; + case STD_VIDEO_AV1_LEVEL_5_1: + dump_enum(settings, "STD_VIDEO_AV1_LEVEL_5_1", static_cast(object)); + break; + case STD_VIDEO_AV1_LEVEL_5_2: + dump_enum(settings, "STD_VIDEO_AV1_LEVEL_5_2", static_cast(object)); + break; + case STD_VIDEO_AV1_LEVEL_5_3: + dump_enum(settings, "STD_VIDEO_AV1_LEVEL_5_3", static_cast(object)); + break; + case STD_VIDEO_AV1_LEVEL_6_0: + dump_enum(settings, "STD_VIDEO_AV1_LEVEL_6_0", static_cast(object)); + break; + case STD_VIDEO_AV1_LEVEL_6_1: + dump_enum(settings, "STD_VIDEO_AV1_LEVEL_6_1", static_cast(object)); + break; + case STD_VIDEO_AV1_LEVEL_6_2: + dump_enum(settings, "STD_VIDEO_AV1_LEVEL_6_2", static_cast(object)); + break; + case STD_VIDEO_AV1_LEVEL_6_3: + dump_enum(settings, "STD_VIDEO_AV1_LEVEL_6_3", static_cast(object)); + break; + case STD_VIDEO_AV1_LEVEL_7_0: + dump_enum(settings, "STD_VIDEO_AV1_LEVEL_7_0", static_cast(object)); + break; + case STD_VIDEO_AV1_LEVEL_7_1: + dump_enum(settings, "STD_VIDEO_AV1_LEVEL_7_1", static_cast(object)); + break; + case STD_VIDEO_AV1_LEVEL_7_2: + dump_enum(settings, "STD_VIDEO_AV1_LEVEL_7_2", static_cast(object)); + break; + case STD_VIDEO_AV1_LEVEL_7_3: + dump_enum(settings, "STD_VIDEO_AV1_LEVEL_7_3", static_cast(object)); + break; + case STD_VIDEO_AV1_LEVEL_INVALID: + dump_enum(settings, "STD_VIDEO_AV1_LEVEL_INVALID", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_StdVideoAV1FrameType(const StdVideoAV1FrameType object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case STD_VIDEO_AV1_FRAME_TYPE_KEY: + dump_enum(settings, "STD_VIDEO_AV1_FRAME_TYPE_KEY", static_cast(object)); + break; + case STD_VIDEO_AV1_FRAME_TYPE_INTER: + dump_enum(settings, "STD_VIDEO_AV1_FRAME_TYPE_INTER", static_cast(object)); + break; + case STD_VIDEO_AV1_FRAME_TYPE_INTRA_ONLY: + dump_enum(settings, "STD_VIDEO_AV1_FRAME_TYPE_INTRA_ONLY", static_cast(object)); + break; + case STD_VIDEO_AV1_FRAME_TYPE_SWITCH: + dump_enum(settings, "STD_VIDEO_AV1_FRAME_TYPE_SWITCH", static_cast(object)); + break; + case STD_VIDEO_AV1_FRAME_TYPE_INVALID: + dump_enum(settings, "STD_VIDEO_AV1_FRAME_TYPE_INVALID", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_StdVideoAV1ReferenceName(const StdVideoAV1ReferenceName object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case STD_VIDEO_AV1_REFERENCE_NAME_INTRA_FRAME: + dump_enum(settings, "STD_VIDEO_AV1_REFERENCE_NAME_INTRA_FRAME", static_cast(object)); + break; + case STD_VIDEO_AV1_REFERENCE_NAME_LAST_FRAME: + dump_enum(settings, "STD_VIDEO_AV1_REFERENCE_NAME_LAST_FRAME", static_cast(object)); + break; + case STD_VIDEO_AV1_REFERENCE_NAME_LAST2_FRAME: + dump_enum(settings, "STD_VIDEO_AV1_REFERENCE_NAME_LAST2_FRAME", static_cast(object)); + break; + case STD_VIDEO_AV1_REFERENCE_NAME_LAST3_FRAME: + dump_enum(settings, "STD_VIDEO_AV1_REFERENCE_NAME_LAST3_FRAME", static_cast(object)); + break; + case STD_VIDEO_AV1_REFERENCE_NAME_GOLDEN_FRAME: + dump_enum(settings, "STD_VIDEO_AV1_REFERENCE_NAME_GOLDEN_FRAME", static_cast(object)); + break; + case STD_VIDEO_AV1_REFERENCE_NAME_BWDREF_FRAME: + dump_enum(settings, "STD_VIDEO_AV1_REFERENCE_NAME_BWDREF_FRAME", static_cast(object)); + break; + case STD_VIDEO_AV1_REFERENCE_NAME_ALTREF2_FRAME: + dump_enum(settings, "STD_VIDEO_AV1_REFERENCE_NAME_ALTREF2_FRAME", static_cast(object)); + break; + case STD_VIDEO_AV1_REFERENCE_NAME_ALTREF_FRAME: + dump_enum(settings, "STD_VIDEO_AV1_REFERENCE_NAME_ALTREF_FRAME", static_cast(object)); + break; + case STD_VIDEO_AV1_REFERENCE_NAME_INVALID: + dump_enum(settings, "STD_VIDEO_AV1_REFERENCE_NAME_INVALID", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_StdVideoAV1InterpolationFilter(const StdVideoAV1InterpolationFilter object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP: + dump_enum(settings, "STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP", static_cast(object)); + break; + case STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH: + dump_enum(settings, "STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH", static_cast(object)); + break; + case STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP: + dump_enum(settings, "STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP", static_cast(object)); + break; + case STD_VIDEO_AV1_INTERPOLATION_FILTER_BILINEAR: + dump_enum(settings, "STD_VIDEO_AV1_INTERPOLATION_FILTER_BILINEAR", static_cast(object)); + break; + case STD_VIDEO_AV1_INTERPOLATION_FILTER_SWITCHABLE: + dump_enum(settings, "STD_VIDEO_AV1_INTERPOLATION_FILTER_SWITCHABLE", static_cast(object)); + break; + case STD_VIDEO_AV1_INTERPOLATION_FILTER_INVALID: + dump_enum(settings, "STD_VIDEO_AV1_INTERPOLATION_FILTER_INVALID", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_StdVideoAV1TxMode(const StdVideoAV1TxMode object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case STD_VIDEO_AV1_TX_MODE_ONLY_4X4: + dump_enum(settings, "STD_VIDEO_AV1_TX_MODE_ONLY_4X4", static_cast(object)); + break; + case STD_VIDEO_AV1_TX_MODE_LARGEST: + dump_enum(settings, "STD_VIDEO_AV1_TX_MODE_LARGEST", static_cast(object)); + break; + case STD_VIDEO_AV1_TX_MODE_SELECT: + dump_enum(settings, "STD_VIDEO_AV1_TX_MODE_SELECT", static_cast(object)); + break; + case STD_VIDEO_AV1_TX_MODE_INVALID: + dump_enum(settings, "STD_VIDEO_AV1_TX_MODE_INVALID", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_StdVideoAV1FrameRestorationType(const StdVideoAV1FrameRestorationType object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_NONE: + dump_enum(settings, "STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_NONE", static_cast(object)); + break; + case STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_WIENER: + dump_enum(settings, "STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_WIENER", static_cast(object)); + break; + case STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SGRPROJ: + dump_enum(settings, "STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SGRPROJ", static_cast(object)); + break; + case STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SWITCHABLE: + dump_enum(settings, "STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SWITCHABLE", static_cast(object)); + break; + case STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_INVALID: + dump_enum(settings, "STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_INVALID", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_StdVideoAV1ColorPrimaries(const StdVideoAV1ColorPrimaries object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case STD_VIDEO_AV1_COLOR_PRIMARIES_BT_709: + dump_enum(settings, "STD_VIDEO_AV1_COLOR_PRIMARIES_BT_709", static_cast(object)); + break; + case STD_VIDEO_AV1_COLOR_PRIMARIES_UNSPECIFIED: + dump_enum(settings, "STD_VIDEO_AV1_COLOR_PRIMARIES_UNSPECIFIED", static_cast(object)); + break; + case STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_M: + dump_enum(settings, "STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_M", static_cast(object)); + break; + case STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_B_G: + dump_enum(settings, "STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_B_G", static_cast(object)); + break; + case STD_VIDEO_AV1_COLOR_PRIMARIES_BT_601: + dump_enum(settings, "STD_VIDEO_AV1_COLOR_PRIMARIES_BT_601", static_cast(object)); + break; + case STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_240: + dump_enum(settings, "STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_240", static_cast(object)); + break; + case STD_VIDEO_AV1_COLOR_PRIMARIES_GENERIC_FILM: + dump_enum(settings, "STD_VIDEO_AV1_COLOR_PRIMARIES_GENERIC_FILM", static_cast(object)); + break; + case STD_VIDEO_AV1_COLOR_PRIMARIES_BT_2020: + dump_enum(settings, "STD_VIDEO_AV1_COLOR_PRIMARIES_BT_2020", static_cast(object)); + break; + case STD_VIDEO_AV1_COLOR_PRIMARIES_XYZ: + dump_enum(settings, "STD_VIDEO_AV1_COLOR_PRIMARIES_XYZ", static_cast(object)); + break; + case STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_431: + dump_enum(settings, "STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_431", static_cast(object)); + break; + case STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_432: + dump_enum(settings, "STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_432", static_cast(object)); + break; + case STD_VIDEO_AV1_COLOR_PRIMARIES_EBU_3213: + dump_enum(settings, "STD_VIDEO_AV1_COLOR_PRIMARIES_EBU_3213", static_cast(object)); + break; + case STD_VIDEO_AV1_COLOR_PRIMARIES_INVALID: + dump_enum(settings, "STD_VIDEO_AV1_COLOR_PRIMARIES_INVALID", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_StdVideoAV1TransferCharacteristics(const StdVideoAV1TransferCharacteristics object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_0: + dump_enum(settings, "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_0", static_cast(object)); + break; + case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_709: + dump_enum(settings, "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_709", static_cast(object)); + break; + case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_UNSPECIFIED: + dump_enum(settings, "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_UNSPECIFIED", static_cast(object)); + break; + case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_3: + dump_enum(settings, "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_3", static_cast(object)); + break; + case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_M: + dump_enum(settings, "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_M", static_cast(object)); + break; + case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_B_G: + dump_enum(settings, "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_B_G", static_cast(object)); + break; + case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_601: + dump_enum(settings, "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_601", static_cast(object)); + break; + case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_240: + dump_enum(settings, "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_240", static_cast(object)); + break; + case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LINEAR: + dump_enum(settings, "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LINEAR", static_cast(object)); + break; + case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100: + dump_enum(settings, "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100", static_cast(object)); + break; + case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100_SQRT10: + dump_enum(settings, "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100_SQRT10", static_cast(object)); + break; + case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_IEC_61966: + dump_enum(settings, "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_IEC_61966", static_cast(object)); + break; + case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_1361: + dump_enum(settings, "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_1361", static_cast(object)); + break; + case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SRGB: + dump_enum(settings, "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SRGB", static_cast(object)); + break; + case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_10_BIT: + dump_enum(settings, "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_10_BIT", static_cast(object)); + break; + case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_12_BIT: + dump_enum(settings, "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_12_BIT", static_cast(object)); + break; + case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_2084: + dump_enum(settings, "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_2084", static_cast(object)); + break; + case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_428: + dump_enum(settings, "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_428", static_cast(object)); + break; + case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_HLG: + dump_enum(settings, "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_HLG", static_cast(object)); + break; + case STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_INVALID: + dump_enum(settings, "STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_INVALID", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_StdVideoAV1MatrixCoefficients(const StdVideoAV1MatrixCoefficients object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_IDENTITY: + dump_enum(settings, "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_IDENTITY", static_cast(object)); + break; + case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_709: + dump_enum(settings, "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_709", static_cast(object)); + break; + case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_UNSPECIFIED: + dump_enum(settings, "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_UNSPECIFIED", static_cast(object)); + break; + case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_RESERVED_3: + dump_enum(settings, "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_RESERVED_3", static_cast(object)); + break; + case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_FCC: + dump_enum(settings, "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_FCC", static_cast(object)); + break; + case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_470_B_G: + dump_enum(settings, "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_470_B_G", static_cast(object)); + break; + case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_601: + dump_enum(settings, "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_601", static_cast(object)); + break; + case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_240: + dump_enum(settings, "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_240", static_cast(object)); + break; + case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_YCGCO: + dump_enum(settings, "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_YCGCO", static_cast(object)); + break; + case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_NCL: + dump_enum(settings, "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_NCL", static_cast(object)); + break; + case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_CL: + dump_enum(settings, "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_CL", static_cast(object)); + break; + case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_2085: + dump_enum(settings, "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_2085", static_cast(object)); + break; + case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_NCL: + dump_enum(settings, "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_NCL", static_cast(object)); + break; + case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_CL: + dump_enum(settings, "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_CL", static_cast(object)); + break; + case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_ICTCP: + dump_enum(settings, "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_ICTCP", static_cast(object)); + break; + case STD_VIDEO_AV1_MATRIX_COEFFICIENTS_INVALID: + dump_enum(settings, "STD_VIDEO_AV1_MATRIX_COEFFICIENTS_INVALID", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_StdVideoAV1ChromaSamplePosition(const StdVideoAV1ChromaSamplePosition object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_UNKNOWN: + dump_enum(settings, "STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_UNKNOWN", static_cast(object)); + break; + case STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_VERTICAL: + dump_enum(settings, "STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_VERTICAL", static_cast(object)); + break; + case STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_COLOCATED: + dump_enum(settings, "STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_COLOCATED", static_cast(object)); + break; + case STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_RESERVED: + dump_enum(settings, "STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_RESERVED", static_cast(object)); + break; + case STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_INVALID: + dump_enum(settings, "STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_INVALID", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_StdVideoVP9Profile(const StdVideoVP9Profile object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case STD_VIDEO_VP9_PROFILE_0: + dump_enum(settings, "STD_VIDEO_VP9_PROFILE_0", static_cast(object)); + break; + case STD_VIDEO_VP9_PROFILE_1: + dump_enum(settings, "STD_VIDEO_VP9_PROFILE_1", static_cast(object)); + break; + case STD_VIDEO_VP9_PROFILE_2: + dump_enum(settings, "STD_VIDEO_VP9_PROFILE_2", static_cast(object)); + break; + case STD_VIDEO_VP9_PROFILE_3: + dump_enum(settings, "STD_VIDEO_VP9_PROFILE_3", static_cast(object)); + break; + case STD_VIDEO_VP9_PROFILE_INVALID: + dump_enum(settings, "STD_VIDEO_VP9_PROFILE_INVALID", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_StdVideoVP9Level(const StdVideoVP9Level object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case STD_VIDEO_VP9_LEVEL_1_0: + dump_enum(settings, "STD_VIDEO_VP9_LEVEL_1_0", static_cast(object)); + break; + case STD_VIDEO_VP9_LEVEL_1_1: + dump_enum(settings, "STD_VIDEO_VP9_LEVEL_1_1", static_cast(object)); + break; + case STD_VIDEO_VP9_LEVEL_2_0: + dump_enum(settings, "STD_VIDEO_VP9_LEVEL_2_0", static_cast(object)); + break; + case STD_VIDEO_VP9_LEVEL_2_1: + dump_enum(settings, "STD_VIDEO_VP9_LEVEL_2_1", static_cast(object)); + break; + case STD_VIDEO_VP9_LEVEL_3_0: + dump_enum(settings, "STD_VIDEO_VP9_LEVEL_3_0", static_cast(object)); + break; + case STD_VIDEO_VP9_LEVEL_3_1: + dump_enum(settings, "STD_VIDEO_VP9_LEVEL_3_1", static_cast(object)); + break; + case STD_VIDEO_VP9_LEVEL_4_0: + dump_enum(settings, "STD_VIDEO_VP9_LEVEL_4_0", static_cast(object)); + break; + case STD_VIDEO_VP9_LEVEL_4_1: + dump_enum(settings, "STD_VIDEO_VP9_LEVEL_4_1", static_cast(object)); + break; + case STD_VIDEO_VP9_LEVEL_5_0: + dump_enum(settings, "STD_VIDEO_VP9_LEVEL_5_0", static_cast(object)); + break; + case STD_VIDEO_VP9_LEVEL_5_1: + dump_enum(settings, "STD_VIDEO_VP9_LEVEL_5_1", static_cast(object)); + break; + case STD_VIDEO_VP9_LEVEL_5_2: + dump_enum(settings, "STD_VIDEO_VP9_LEVEL_5_2", static_cast(object)); + break; + case STD_VIDEO_VP9_LEVEL_6_0: + dump_enum(settings, "STD_VIDEO_VP9_LEVEL_6_0", static_cast(object)); + break; + case STD_VIDEO_VP9_LEVEL_6_1: + dump_enum(settings, "STD_VIDEO_VP9_LEVEL_6_1", static_cast(object)); + break; + case STD_VIDEO_VP9_LEVEL_6_2: + dump_enum(settings, "STD_VIDEO_VP9_LEVEL_6_2", static_cast(object)); + break; + case STD_VIDEO_VP9_LEVEL_INVALID: + dump_enum(settings, "STD_VIDEO_VP9_LEVEL_INVALID", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_StdVideoVP9FrameType(const StdVideoVP9FrameType object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case STD_VIDEO_VP9_FRAME_TYPE_KEY: + dump_enum(settings, "STD_VIDEO_VP9_FRAME_TYPE_KEY", static_cast(object)); + break; + case STD_VIDEO_VP9_FRAME_TYPE_NON_KEY: + dump_enum(settings, "STD_VIDEO_VP9_FRAME_TYPE_NON_KEY", static_cast(object)); + break; + case STD_VIDEO_VP9_FRAME_TYPE_INVALID: + dump_enum(settings, "STD_VIDEO_VP9_FRAME_TYPE_INVALID", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_StdVideoVP9ReferenceName(const StdVideoVP9ReferenceName object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case STD_VIDEO_VP9_REFERENCE_NAME_INTRA_FRAME: + dump_enum(settings, "STD_VIDEO_VP9_REFERENCE_NAME_INTRA_FRAME", static_cast(object)); + break; + case STD_VIDEO_VP9_REFERENCE_NAME_LAST_FRAME: + dump_enum(settings, "STD_VIDEO_VP9_REFERENCE_NAME_LAST_FRAME", static_cast(object)); + break; + case STD_VIDEO_VP9_REFERENCE_NAME_GOLDEN_FRAME: + dump_enum(settings, "STD_VIDEO_VP9_REFERENCE_NAME_GOLDEN_FRAME", static_cast(object)); + break; + case STD_VIDEO_VP9_REFERENCE_NAME_ALTREF_FRAME: + dump_enum(settings, "STD_VIDEO_VP9_REFERENCE_NAME_ALTREF_FRAME", static_cast(object)); + break; + case STD_VIDEO_VP9_REFERENCE_NAME_INVALID: + dump_enum(settings, "STD_VIDEO_VP9_REFERENCE_NAME_INVALID", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_StdVideoVP9InterpolationFilter(const StdVideoVP9InterpolationFilter object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP: + dump_enum(settings, "STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP", static_cast(object)); + break; + case STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH: + dump_enum(settings, "STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH", static_cast(object)); + break; + case STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SHARP: + dump_enum(settings, "STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SHARP", static_cast(object)); + break; + case STD_VIDEO_VP9_INTERPOLATION_FILTER_BILINEAR: + dump_enum(settings, "STD_VIDEO_VP9_INTERPOLATION_FILTER_BILINEAR", static_cast(object)); + break; + case STD_VIDEO_VP9_INTERPOLATION_FILTER_SWITCHABLE: + dump_enum(settings, "STD_VIDEO_VP9_INTERPOLATION_FILTER_SWITCHABLE", static_cast(object)); + break; + case STD_VIDEO_VP9_INTERPOLATION_FILTER_INVALID: + dump_enum(settings, "STD_VIDEO_VP9_INTERPOLATION_FILTER_INVALID", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_StdVideoVP9ColorSpace(const StdVideoVP9ColorSpace object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case STD_VIDEO_VP9_COLOR_SPACE_UNKNOWN: + dump_enum(settings, "STD_VIDEO_VP9_COLOR_SPACE_UNKNOWN", static_cast(object)); + break; + case STD_VIDEO_VP9_COLOR_SPACE_BT_601: + dump_enum(settings, "STD_VIDEO_VP9_COLOR_SPACE_BT_601", static_cast(object)); + break; + case STD_VIDEO_VP9_COLOR_SPACE_BT_709: + dump_enum(settings, "STD_VIDEO_VP9_COLOR_SPACE_BT_709", static_cast(object)); + break; + case STD_VIDEO_VP9_COLOR_SPACE_SMPTE_170: + dump_enum(settings, "STD_VIDEO_VP9_COLOR_SPACE_SMPTE_170", static_cast(object)); + break; + case STD_VIDEO_VP9_COLOR_SPACE_SMPTE_240: + dump_enum(settings, "STD_VIDEO_VP9_COLOR_SPACE_SMPTE_240", static_cast(object)); + break; + case STD_VIDEO_VP9_COLOR_SPACE_BT_2020: + dump_enum(settings, "STD_VIDEO_VP9_COLOR_SPACE_BT_2020", static_cast(object)); + break; + case STD_VIDEO_VP9_COLOR_SPACE_RESERVED: + dump_enum(settings, "STD_VIDEO_VP9_COLOR_SPACE_RESERVED", static_cast(object)); + break; + case STD_VIDEO_VP9_COLOR_SPACE_RGB: + dump_enum(settings, "STD_VIDEO_VP9_COLOR_SPACE_RGB", static_cast(object)); + break; + case STD_VIDEO_VP9_COLOR_SPACE_INVALID: + dump_enum(settings, "STD_VIDEO_VP9_COLOR_SPACE_INVALID", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} + +//=========================== Enum Implementations ==========================// + +template +void dump_return_value_VkResult(const VkResult& object, const ApiDumpSettings& settings) { + switch ((int64_t)object) { + case VK_SUCCESS: + dump_enum(settings, "VK_SUCCESS", static_cast(object)); + break; + case VK_NOT_READY: + dump_enum(settings, "VK_NOT_READY", static_cast(object)); + break; + case VK_TIMEOUT: + dump_enum(settings, "VK_TIMEOUT", static_cast(object)); + break; + case VK_EVENT_SET: + dump_enum(settings, "VK_EVENT_SET", static_cast(object)); + break; + case VK_EVENT_RESET: + dump_enum(settings, "VK_EVENT_RESET", static_cast(object)); + break; + case VK_INCOMPLETE: + dump_enum(settings, "VK_INCOMPLETE", static_cast(object)); + break; + case VK_ERROR_OUT_OF_HOST_MEMORY: + dump_enum(settings, "VK_ERROR_OUT_OF_HOST_MEMORY", static_cast(object)); + break; + case VK_ERROR_OUT_OF_DEVICE_MEMORY: + dump_enum(settings, "VK_ERROR_OUT_OF_DEVICE_MEMORY", static_cast(object)); + break; + case VK_ERROR_INITIALIZATION_FAILED: + dump_enum(settings, "VK_ERROR_INITIALIZATION_FAILED", static_cast(object)); + break; + case VK_ERROR_DEVICE_LOST: + dump_enum(settings, "VK_ERROR_DEVICE_LOST", static_cast(object)); + break; + case VK_ERROR_MEMORY_MAP_FAILED: + dump_enum(settings, "VK_ERROR_MEMORY_MAP_FAILED", static_cast(object)); + break; + case VK_ERROR_LAYER_NOT_PRESENT: + dump_enum(settings, "VK_ERROR_LAYER_NOT_PRESENT", static_cast(object)); + break; + case VK_ERROR_EXTENSION_NOT_PRESENT: + dump_enum(settings, "VK_ERROR_EXTENSION_NOT_PRESENT", static_cast(object)); + break; + case VK_ERROR_FEATURE_NOT_PRESENT: + dump_enum(settings, "VK_ERROR_FEATURE_NOT_PRESENT", static_cast(object)); + break; + case VK_ERROR_INCOMPATIBLE_DRIVER: + dump_enum(settings, "VK_ERROR_INCOMPATIBLE_DRIVER", static_cast(object)); + break; + case VK_ERROR_TOO_MANY_OBJECTS: + dump_enum(settings, "VK_ERROR_TOO_MANY_OBJECTS", static_cast(object)); + break; + case VK_ERROR_FORMAT_NOT_SUPPORTED: + dump_enum(settings, "VK_ERROR_FORMAT_NOT_SUPPORTED", static_cast(object)); + break; + case VK_ERROR_FRAGMENTED_POOL: + dump_enum(settings, "VK_ERROR_FRAGMENTED_POOL", static_cast(object)); + break; + case VK_ERROR_UNKNOWN: + dump_enum(settings, "VK_ERROR_UNKNOWN", static_cast(object)); + break; + case VK_ERROR_VALIDATION_FAILED: + dump_enum(settings, "VK_ERROR_VALIDATION_FAILED", static_cast(object)); + break; + case VK_ERROR_OUT_OF_POOL_MEMORY: + dump_enum(settings, "VK_ERROR_OUT_OF_POOL_MEMORY", static_cast(object)); + break; + case VK_ERROR_INVALID_EXTERNAL_HANDLE: + dump_enum(settings, "VK_ERROR_INVALID_EXTERNAL_HANDLE", static_cast(object)); + break; + case VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS: + dump_enum(settings, "VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS", static_cast(object)); + break; + case VK_ERROR_FRAGMENTATION: + dump_enum(settings, "VK_ERROR_FRAGMENTATION", static_cast(object)); + break; + case VK_PIPELINE_COMPILE_REQUIRED: + dump_enum(settings, "VK_PIPELINE_COMPILE_REQUIRED", static_cast(object)); + break; + case VK_ERROR_NOT_PERMITTED: + dump_enum(settings, "VK_ERROR_NOT_PERMITTED", static_cast(object)); + break; + case VK_ERROR_SURFACE_LOST_KHR: + dump_enum(settings, "VK_ERROR_SURFACE_LOST_KHR", static_cast(object)); + break; + case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR: + dump_enum(settings, "VK_ERROR_NATIVE_WINDOW_IN_USE_KHR", static_cast(object)); + break; + case VK_SUBOPTIMAL_KHR: + dump_enum(settings, "VK_SUBOPTIMAL_KHR", static_cast(object)); + break; + case VK_ERROR_OUT_OF_DATE_KHR: + dump_enum(settings, "VK_ERROR_OUT_OF_DATE_KHR", static_cast(object)); + break; + case VK_ERROR_INCOMPATIBLE_DISPLAY_KHR: + dump_enum(settings, "VK_ERROR_INCOMPATIBLE_DISPLAY_KHR", static_cast(object)); + break; + case VK_ERROR_INVALID_SHADER_NV: + dump_enum(settings, "VK_ERROR_INVALID_SHADER_NV", static_cast(object)); + break; + case VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR: + dump_enum(settings, "VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR", static_cast(object)); + break; + case VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR: + dump_enum(settings, "VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR", static_cast(object)); + break; + case VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR: + dump_enum(settings, "VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR", static_cast(object)); + break; + case VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR: + dump_enum(settings, "VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR", static_cast(object)); + break; + case VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR: + dump_enum(settings, "VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR", static_cast(object)); + break; + case VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR: + dump_enum(settings, "VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR", static_cast(object)); + break; + case VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT: + dump_enum(settings, "VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT", static_cast(object)); + break; + case VK_ERROR_PRESENT_TIMING_QUEUE_FULL_EXT: + dump_enum(settings, "VK_ERROR_PRESENT_TIMING_QUEUE_FULL_EXT", static_cast(object)); + break; + case VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT: + dump_enum(settings, "VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT", static_cast(object)); + break; + case VK_THREAD_IDLE_KHR: + dump_enum(settings, "VK_THREAD_IDLE_KHR", static_cast(object)); + break; + case VK_THREAD_DONE_KHR: + dump_enum(settings, "VK_THREAD_DONE_KHR", static_cast(object)); + break; + case VK_OPERATION_DEFERRED_KHR: + dump_enum(settings, "VK_OPERATION_DEFERRED_KHR", static_cast(object)); + break; + case VK_OPERATION_NOT_DEFERRED_KHR: + dump_enum(settings, "VK_OPERATION_NOT_DEFERRED_KHR", static_cast(object)); + break; + case VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR: + dump_enum(settings, "VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR", static_cast(object)); + break; + case VK_ERROR_COMPRESSION_EXHAUSTED_EXT: + dump_enum(settings, "VK_ERROR_COMPRESSION_EXHAUSTED_EXT", static_cast(object)); + break; + case VK_INCOMPATIBLE_SHADER_BINARY_EXT: + dump_enum(settings, "VK_INCOMPATIBLE_SHADER_BINARY_EXT", static_cast(object)); + break; + case VK_PIPELINE_BINARY_MISSING_KHR: + dump_enum(settings, "VK_PIPELINE_BINARY_MISSING_KHR", static_cast(object)); + break; + case VK_ERROR_NOT_ENOUGH_SPACE_KHR: + dump_enum(settings, "VK_ERROR_NOT_ENOUGH_SPACE_KHR", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } +} +template +void dump_VkResult(const VkResult object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_return_value_VkResult(object, settings); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkStructureType(const VkStructureType object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_STRUCTURE_TYPE_APPLICATION_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_APPLICATION_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SUBMIT_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_SUBMIT_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE: + dump_enum(settings, "VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_BIND_SPARSE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_BIND_SPARSE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_FENCE_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_FENCE_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_EVENT_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_EVENT_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET: + dump_enum(settings, "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET: + dump_enum(settings, "VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER: + dump_enum(settings, "VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_MEMORY_BARRIER: + dump_enum(settings, "VK_STRUCTURE_TYPE_MEMORY_BARRIER", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: + dump_enum(settings, "VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2: + dump_enum(settings, "VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2: + dump_enum(settings, "VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2: + dump_enum(settings, "VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2: + dump_enum(settings, "VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2: + dump_enum(settings, "VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2: + dump_enum(settings, "VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES: + dump_enum(settings, "VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES: + dump_enum(settings, "VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES: + dump_enum(settings, "VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES: + dump_enum(settings, "VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT: + dump_enum(settings, "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: + dump_enum(settings, "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT: + dump_enum(settings, "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2: + dump_enum(settings, "VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2: + dump_enum(settings, "VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2: + dump_enum(settings, "VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2: + dump_enum(settings, "VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2: + dump_enum(settings, "VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SUBPASS_END_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_SUBPASS_END_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE: + dump_enum(settings, "VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT: + dump_enum(settings, "VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT: + dump_enum(settings, "VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2: + dump_enum(settings, "VK_STRUCTURE_TYPE_MEMORY_BARRIER_2", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2: + dump_enum(settings, "VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEPENDENCY_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEPENDENCY_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SUBMIT_INFO_2: + dump_enum(settings, "VK_STRUCTURE_TYPE_SUBMIT_INFO_2", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2: + dump_enum(settings, "VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2: + dump_enum(settings, "VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2: + dump_enum(settings, "VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2: + dump_enum(settings, "VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_BUFFER_COPY_2: + dump_enum(settings, "VK_STRUCTURE_TYPE_BUFFER_COPY_2", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMAGE_COPY_2: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMAGE_COPY_2", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2: + dump_enum(settings, "VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3: + dump_enum(settings, "VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK: + dump_enum(settings, "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2: + dump_enum(settings, "VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2: + dump_enum(settings, "VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMAGE_BLIT_2: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMAGE_BLIT_2", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_RENDERING_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_RENDERING_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES: + dump_enum(settings, "VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_MEMORY_MAP_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_MEMORY_MAP_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2: + dump_enum(settings, "VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS: + dump_enum(settings, "VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY: + dump_enum(settings, "VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE: + dump_enum(settings, "VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY: + dump_enum(settings, "VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_RENDERING_AREA_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_RENDERING_AREA_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO: + dump_enum(settings, "VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PRESENT_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PRESENT_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX: + dump_enum(settings, "VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX: + dump_enum(settings, "VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX: + dump_enum(settings, "VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX: + dump_enum(settings, "VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: + dump_enum(settings, "VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP: + dump_enum(settings, "VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN: + dump_enum(settings, "VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE: + dump_enum(settings, "VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: + dump_enum(settings, "VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_HDR_METADATA_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_HDR_METADATA_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK: + dump_enum(settings, "VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK: + dump_enum(settings, "VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID: + dump_enum(settings, "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID: + dump_enum(settings, "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID: + dump_enum(settings, "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: + dump_enum(settings, "VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID: + dump_enum(settings, "VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID: + dump_enum(settings, "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID", static_cast(object)); + break; +#if defined(VK_ENABLE_BETA_EXTENSIONS) + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX: + dump_enum(settings, "VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX: + dump_enum(settings, "VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX", static_cast(object)); + break; +#endif // VK_ENABLE_BETA_EXTENSIONS + case VK_STRUCTURE_TYPE_TEXEL_BUFFER_DESCRIPTOR_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_TEXEL_BUFFER_DESCRIPTOR_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMAGE_DESCRIPTOR_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMAGE_DESCRIPTOR_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_BIND_HEAP_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_BIND_HEAP_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PUSH_DATA_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PUSH_DATA_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_AND_BINDING_MAPPING_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_AND_BINDING_MAPPING_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SHADER_DESCRIPTOR_SET_AND_BINDING_MAPPING_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_SHADER_DESCRIPTOR_SET_AND_BINDING_MAPPING_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DATA_CREATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DATA_CREATE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_DESCRIPTOR_HEAP_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_DESCRIPTOR_HEAP_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_INDEX_CREATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_INDEX_CREATE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_PUSH_DATA_TOKEN_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_PUSH_DATA_TOKEN_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SUBSAMPLED_IMAGE_FORMAT_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_SUBSAMPLED_IMAGE_FORMAT_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_TENSOR_PROPERTIES_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_TENSOR_PROPERTIES_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: + dump_enum(settings, "VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT", static_cast(object)); + break; +#if defined(VK_ENABLE_BETA_EXTENSIONS) + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR", static_cast(object)); + break; +#endif // VK_ENABLE_BETA_EXTENSIONS + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_GEOMETRY_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_GEOMETRY_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP: + dump_enum(settings, "VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_TIMING_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_SWAPCHAIN_TIMING_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_TIME_DOMAIN_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_SWAPCHAIN_TIME_DOMAIN_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PRESENT_TIMING_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PRESENT_TIMING_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL: + dump_enum(settings, "VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL: + dump_enum(settings, "VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL: + dump_enum(settings, "VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL: + dump_enum(settings, "VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL: + dump_enum(settings, "VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL: + dump_enum(settings, "VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD: + dump_enum(settings, "VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD: + dump_enum(settings, "VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM: + dump_enum(settings, "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: + dump_enum(settings, "VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PRESENT_ID_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PRESENT_ID_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV", static_cast(object)); + break; +#if defined(VK_ENABLE_BETA_EXTENSIONS) + case VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV", static_cast(object)); + break; +#endif // VK_ENABLE_BETA_EXTENSIONS + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM: + dump_enum(settings, "VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM: + dump_enum(settings, "VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM: + dump_enum(settings, "VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM: + dump_enum(settings, "VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM: + dump_enum(settings, "VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA: + dump_enum(settings, "VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA: + dump_enum(settings, "VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA: + dump_enum(settings, "VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA: + dump_enum(settings, "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA: + dump_enum(settings, "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA: + dump_enum(settings, "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA: + dump_enum(settings, "VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA: + dump_enum(settings, "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA: + dump_enum(settings, "VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA: + dump_enum(settings, "VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI: + dump_enum(settings, "VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX: + dump_enum(settings, "VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT", static_cast(object)); + break; +#if defined(VK_ENABLE_BETA_EXTENSIONS) + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV", static_cast(object)); + break; +#endif // VK_ENABLE_BETA_EXTENSIONS + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE: + dump_enum(settings, "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE: + dump_enum(settings, "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS: + dump_enum(settings, "VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS: + dump_enum(settings, "VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS: + dump_enum(settings, "VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS: + dump_enum(settings, "VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS: + dump_enum(settings, "VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG: + dump_enum(settings, "VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG: + dump_enum(settings, "VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_COPY_TENSOR_INFO_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_COPY_TENSOR_INFO_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_TENSOR_COPY_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_TENSOR_COPY_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_TENSOR_PROPERTIES_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_EXTERNAL_TENSOR_PROPERTIES_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID: + dump_enum(settings, "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD: + dump_enum(settings, "VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD: + dump_enum(settings, "VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD", static_cast(object)); + break; +#if defined(VK_ENABLE_BETA_EXTENSIONS) + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA_AMDX: + dump_enum(settings, "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA_AMDX", static_cast(object)); + break; +#endif // VK_ENABLE_BETA_EXTENSIONS + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM: + dump_enum(settings, "VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC: + dump_enum(settings, "VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_COOPERATIVE_VECTOR_PROPERTIES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_COOPERATIVE_VECTOR_PROPERTIES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CREATE_INFO_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CREATE_INFO_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_CREATE_INFO_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_CREATE_INFO_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_MEMORY_REQUIREMENTS_INFO_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_MEMORY_REQUIREMENTS_INFO_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_BIND_DATA_GRAPH_PIPELINE_SESSION_MEMORY_INFO_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_BIND_DATA_GRAPH_PIPELINE_SESSION_MEMORY_INFO_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_PROPERTY_QUERY_RESULT_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_PROPERTY_QUERY_RESULT_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_INFO_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_INFO_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENTS_INFO_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENTS_INFO_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENT_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENT_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_DISPATCH_INFO_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_DISPATCH_INFO_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_PROPERTIES_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_PROPERTIES_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROPERTIES_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROPERTIES_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_INFO_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_INFO_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM: + dump_enum(settings, "VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM: + dump_enum(settings, "VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM: + dump_enum(settings, "VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM: + dump_enum(settings, "VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM: + dump_enum(settings, "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX: + dump_enum(settings, "VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX: + dump_enum(settings, "VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX: + dump_enum(settings, "VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM: + dump_enum(settings, "VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM: + dump_enum(settings, "VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM: + dump_enum(settings, "VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_COPY_MEMORY_INDIRECT_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_COPY_MEMORY_INDIRECT_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INDIRECT_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INDIRECT_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DECOMPRESS_MEMORY_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_DECOMPRESS_MEMORY_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PUSH_CONSTANT_BANK_INFO_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PUSH_CONSTANT_BANK_INFO_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_FEATURES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_FEATURES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_PROPERTIES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_PROPERTIES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS: + dump_enum(settings, "VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI: + dump_enum(settings, "VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_MEMORY_METAL_HANDLE_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_MEMORY_METAL_HANDLE_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_FEATURES_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_FEATURES_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_PROPERTIES_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_PROPERTIES_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_PERFORMANCE_COUNTERS_BY_REGION_BEGIN_INFO_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_RENDER_PASS_PERFORMANCE_COUNTERS_BY_REGION_BEGIN_INFO_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE: + dump_enum(settings, "VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR", static_cast(object)); + break; +#if defined(VK_ENABLE_BETA_EXTENSIONS) + case VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV", static_cast(object)); + break; +#endif // VK_ENABLE_BETA_EXTENSIONS + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_BEGIN_CUSTOM_RESOLVE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_BEGIN_CUSTOM_RESOLVE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_CUSTOM_RESOLVE_CREATE_INFO_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_CUSTOM_RESOLVE_CREATE_INFO_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO_QCOM: + dump_enum(settings, "VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO_QCOM", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_FLAGS_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_FLAGS_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_RESOLVE_IMAGE_MODE_INFO_KHR: + dump_enum(settings, "VK_STRUCTURE_TYPE_RESOLVE_IMAGE_MODE_INFO_KHR", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_COMPUTE_OCCUPANCY_PRIORITY_PARAMETERS_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_COMPUTE_OCCUPANCY_PRIORITY_PARAMETERS_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES_NV: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES_NV", static_cast(object)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT: + dump_enum(settings, "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkImageLayout(const VkImageLayout object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_IMAGE_LAYOUT_UNDEFINED: + dump_enum(settings, "VK_IMAGE_LAYOUT_UNDEFINED", static_cast(object)); + break; + case VK_IMAGE_LAYOUT_GENERAL: + dump_enum(settings, "VK_IMAGE_LAYOUT_GENERAL", static_cast(object)); + break; + case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL: + dump_enum(settings, "VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL", static_cast(object)); + break; + case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL: + dump_enum(settings, "VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL", static_cast(object)); + break; + case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL: + dump_enum(settings, "VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL", static_cast(object)); + break; + case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL: + dump_enum(settings, "VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL", static_cast(object)); + break; + case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL: + dump_enum(settings, "VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL", static_cast(object)); + break; + case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL: + dump_enum(settings, "VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL", static_cast(object)); + break; + case VK_IMAGE_LAYOUT_PREINITIALIZED: + dump_enum(settings, "VK_IMAGE_LAYOUT_PREINITIALIZED", static_cast(object)); + break; + case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL: + dump_enum(settings, "VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL", static_cast(object)); + break; + case VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL: + dump_enum(settings, "VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL", static_cast(object)); + break; + case VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL: + dump_enum(settings, "VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL", static_cast(object)); + break; + case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL: + dump_enum(settings, "VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL", static_cast(object)); + break; + case VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL: + dump_enum(settings, "VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL", static_cast(object)); + break; + case VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL: + dump_enum(settings, "VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL", static_cast(object)); + break; + case VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL: + dump_enum(settings, "VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL", static_cast(object)); + break; + case VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL: + dump_enum(settings, "VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL", static_cast(object)); + break; + case VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ: + dump_enum(settings, "VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ", static_cast(object)); + break; + case VK_IMAGE_LAYOUT_PRESENT_SRC_KHR: + dump_enum(settings, "VK_IMAGE_LAYOUT_PRESENT_SRC_KHR", static_cast(object)); + break; + case VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR: + dump_enum(settings, "VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR", static_cast(object)); + break; + case VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR: + dump_enum(settings, "VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR", static_cast(object)); + break; + case VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR: + dump_enum(settings, "VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR", static_cast(object)); + break; + case VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR: + dump_enum(settings, "VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR", static_cast(object)); + break; + case VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT: + dump_enum(settings, "VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT", static_cast(object)); + break; + case VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR: + dump_enum(settings, "VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR", static_cast(object)); + break; + case VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR: + dump_enum(settings, "VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR", static_cast(object)); + break; + case VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR: + dump_enum(settings, "VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR", static_cast(object)); + break; + case VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR: + dump_enum(settings, "VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR", static_cast(object)); + break; + case VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT: + dump_enum(settings, "VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT", static_cast(object)); + break; + case VK_IMAGE_LAYOUT_TENSOR_ALIASING_ARM: + dump_enum(settings, "VK_IMAGE_LAYOUT_TENSOR_ALIASING_ARM", static_cast(object)); + break; + case VK_IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR: + dump_enum(settings, "VK_IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR", static_cast(object)); + break; + case VK_IMAGE_LAYOUT_ZERO_INITIALIZED_EXT: + dump_enum(settings, "VK_IMAGE_LAYOUT_ZERO_INITIALIZED_EXT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkObjectType(const VkObjectType object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_OBJECT_TYPE_UNKNOWN: + dump_enum(settings, "VK_OBJECT_TYPE_UNKNOWN", static_cast(object)); + break; + case VK_OBJECT_TYPE_INSTANCE: + dump_enum(settings, "VK_OBJECT_TYPE_INSTANCE", static_cast(object)); + break; + case VK_OBJECT_TYPE_PHYSICAL_DEVICE: + dump_enum(settings, "VK_OBJECT_TYPE_PHYSICAL_DEVICE", static_cast(object)); + break; + case VK_OBJECT_TYPE_DEVICE: + dump_enum(settings, "VK_OBJECT_TYPE_DEVICE", static_cast(object)); + break; + case VK_OBJECT_TYPE_QUEUE: + dump_enum(settings, "VK_OBJECT_TYPE_QUEUE", static_cast(object)); + break; + case VK_OBJECT_TYPE_SEMAPHORE: + dump_enum(settings, "VK_OBJECT_TYPE_SEMAPHORE", static_cast(object)); + break; + case VK_OBJECT_TYPE_COMMAND_BUFFER: + dump_enum(settings, "VK_OBJECT_TYPE_COMMAND_BUFFER", static_cast(object)); + break; + case VK_OBJECT_TYPE_FENCE: + dump_enum(settings, "VK_OBJECT_TYPE_FENCE", static_cast(object)); + break; + case VK_OBJECT_TYPE_DEVICE_MEMORY: + dump_enum(settings, "VK_OBJECT_TYPE_DEVICE_MEMORY", static_cast(object)); + break; + case VK_OBJECT_TYPE_BUFFER: + dump_enum(settings, "VK_OBJECT_TYPE_BUFFER", static_cast(object)); + break; + case VK_OBJECT_TYPE_IMAGE: + dump_enum(settings, "VK_OBJECT_TYPE_IMAGE", static_cast(object)); + break; + case VK_OBJECT_TYPE_EVENT: + dump_enum(settings, "VK_OBJECT_TYPE_EVENT", static_cast(object)); + break; + case VK_OBJECT_TYPE_QUERY_POOL: + dump_enum(settings, "VK_OBJECT_TYPE_QUERY_POOL", static_cast(object)); + break; + case VK_OBJECT_TYPE_BUFFER_VIEW: + dump_enum(settings, "VK_OBJECT_TYPE_BUFFER_VIEW", static_cast(object)); + break; + case VK_OBJECT_TYPE_IMAGE_VIEW: + dump_enum(settings, "VK_OBJECT_TYPE_IMAGE_VIEW", static_cast(object)); + break; + case VK_OBJECT_TYPE_SHADER_MODULE: + dump_enum(settings, "VK_OBJECT_TYPE_SHADER_MODULE", static_cast(object)); + break; + case VK_OBJECT_TYPE_PIPELINE_CACHE: + dump_enum(settings, "VK_OBJECT_TYPE_PIPELINE_CACHE", static_cast(object)); + break; + case VK_OBJECT_TYPE_PIPELINE_LAYOUT: + dump_enum(settings, "VK_OBJECT_TYPE_PIPELINE_LAYOUT", static_cast(object)); + break; + case VK_OBJECT_TYPE_RENDER_PASS: + dump_enum(settings, "VK_OBJECT_TYPE_RENDER_PASS", static_cast(object)); + break; + case VK_OBJECT_TYPE_PIPELINE: + dump_enum(settings, "VK_OBJECT_TYPE_PIPELINE", static_cast(object)); + break; + case VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT: + dump_enum(settings, "VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT", static_cast(object)); + break; + case VK_OBJECT_TYPE_SAMPLER: + dump_enum(settings, "VK_OBJECT_TYPE_SAMPLER", static_cast(object)); + break; + case VK_OBJECT_TYPE_DESCRIPTOR_POOL: + dump_enum(settings, "VK_OBJECT_TYPE_DESCRIPTOR_POOL", static_cast(object)); + break; + case VK_OBJECT_TYPE_DESCRIPTOR_SET: + dump_enum(settings, "VK_OBJECT_TYPE_DESCRIPTOR_SET", static_cast(object)); + break; + case VK_OBJECT_TYPE_FRAMEBUFFER: + dump_enum(settings, "VK_OBJECT_TYPE_FRAMEBUFFER", static_cast(object)); + break; + case VK_OBJECT_TYPE_COMMAND_POOL: + dump_enum(settings, "VK_OBJECT_TYPE_COMMAND_POOL", static_cast(object)); + break; + case VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE: + dump_enum(settings, "VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE", static_cast(object)); + break; + case VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION: + dump_enum(settings, "VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION", static_cast(object)); + break; + case VK_OBJECT_TYPE_PRIVATE_DATA_SLOT: + dump_enum(settings, "VK_OBJECT_TYPE_PRIVATE_DATA_SLOT", static_cast(object)); + break; + case VK_OBJECT_TYPE_SURFACE_KHR: + dump_enum(settings, "VK_OBJECT_TYPE_SURFACE_KHR", static_cast(object)); + break; + case VK_OBJECT_TYPE_SWAPCHAIN_KHR: + dump_enum(settings, "VK_OBJECT_TYPE_SWAPCHAIN_KHR", static_cast(object)); + break; + case VK_OBJECT_TYPE_DISPLAY_KHR: + dump_enum(settings, "VK_OBJECT_TYPE_DISPLAY_KHR", static_cast(object)); + break; + case VK_OBJECT_TYPE_DISPLAY_MODE_KHR: + dump_enum(settings, "VK_OBJECT_TYPE_DISPLAY_MODE_KHR", static_cast(object)); + break; + case VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT: + dump_enum(settings, "VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT", static_cast(object)); + break; + case VK_OBJECT_TYPE_VIDEO_SESSION_KHR: + dump_enum(settings, "VK_OBJECT_TYPE_VIDEO_SESSION_KHR", static_cast(object)); + break; + case VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR: + dump_enum(settings, "VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR", static_cast(object)); + break; + case VK_OBJECT_TYPE_CU_MODULE_NVX: + dump_enum(settings, "VK_OBJECT_TYPE_CU_MODULE_NVX", static_cast(object)); + break; + case VK_OBJECT_TYPE_CU_FUNCTION_NVX: + dump_enum(settings, "VK_OBJECT_TYPE_CU_FUNCTION_NVX", static_cast(object)); + break; + case VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT: + dump_enum(settings, "VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT", static_cast(object)); + break; + case VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR: + dump_enum(settings, "VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR", static_cast(object)); + break; + case VK_OBJECT_TYPE_VALIDATION_CACHE_EXT: + dump_enum(settings, "VK_OBJECT_TYPE_VALIDATION_CACHE_EXT", static_cast(object)); + break; + case VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV: + dump_enum(settings, "VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV", static_cast(object)); + break; + case VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL: + dump_enum(settings, "VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL", static_cast(object)); + break; + case VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR: + dump_enum(settings, "VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR", static_cast(object)); + break; + case VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV: + dump_enum(settings, "VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV", static_cast(object)); + break; +#if defined(VK_ENABLE_BETA_EXTENSIONS) + case VK_OBJECT_TYPE_CUDA_MODULE_NV: + dump_enum(settings, "VK_OBJECT_TYPE_CUDA_MODULE_NV", static_cast(object)); + break; + case VK_OBJECT_TYPE_CUDA_FUNCTION_NV: + dump_enum(settings, "VK_OBJECT_TYPE_CUDA_FUNCTION_NV", static_cast(object)); + break; +#endif // VK_ENABLE_BETA_EXTENSIONS + case VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA: + dump_enum(settings, "VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA", static_cast(object)); + break; + case VK_OBJECT_TYPE_MICROMAP_EXT: + dump_enum(settings, "VK_OBJECT_TYPE_MICROMAP_EXT", static_cast(object)); + break; + case VK_OBJECT_TYPE_TENSOR_ARM: + dump_enum(settings, "VK_OBJECT_TYPE_TENSOR_ARM", static_cast(object)); + break; + case VK_OBJECT_TYPE_TENSOR_VIEW_ARM: + dump_enum(settings, "VK_OBJECT_TYPE_TENSOR_VIEW_ARM", static_cast(object)); + break; + case VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV: + dump_enum(settings, "VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV", static_cast(object)); + break; + case VK_OBJECT_TYPE_SHADER_EXT: + dump_enum(settings, "VK_OBJECT_TYPE_SHADER_EXT", static_cast(object)); + break; + case VK_OBJECT_TYPE_PIPELINE_BINARY_KHR: + dump_enum(settings, "VK_OBJECT_TYPE_PIPELINE_BINARY_KHR", static_cast(object)); + break; + case VK_OBJECT_TYPE_DATA_GRAPH_PIPELINE_SESSION_ARM: + dump_enum(settings, "VK_OBJECT_TYPE_DATA_GRAPH_PIPELINE_SESSION_ARM", static_cast(object)); + break; + case VK_OBJECT_TYPE_EXTERNAL_COMPUTE_QUEUE_NV: + dump_enum(settings, "VK_OBJECT_TYPE_EXTERNAL_COMPUTE_QUEUE_NV", static_cast(object)); + break; + case VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT: + dump_enum(settings, "VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT", static_cast(object)); + break; + case VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT: + dump_enum(settings, "VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkVendorId(const VkVendorId object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_VENDOR_ID_KHRONOS: + dump_enum(settings, "VK_VENDOR_ID_KHRONOS", static_cast(object)); + break; + case VK_VENDOR_ID_VIV: + dump_enum(settings, "VK_VENDOR_ID_VIV", static_cast(object)); + break; + case VK_VENDOR_ID_VSI: + dump_enum(settings, "VK_VENDOR_ID_VSI", static_cast(object)); + break; + case VK_VENDOR_ID_KAZAN: + dump_enum(settings, "VK_VENDOR_ID_KAZAN", static_cast(object)); + break; + case VK_VENDOR_ID_CODEPLAY: + dump_enum(settings, "VK_VENDOR_ID_CODEPLAY", static_cast(object)); + break; + case VK_VENDOR_ID_MESA: + dump_enum(settings, "VK_VENDOR_ID_MESA", static_cast(object)); + break; + case VK_VENDOR_ID_POCL: + dump_enum(settings, "VK_VENDOR_ID_POCL", static_cast(object)); + break; + case VK_VENDOR_ID_MOBILEYE: + dump_enum(settings, "VK_VENDOR_ID_MOBILEYE", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkSystemAllocationScope(const VkSystemAllocationScope object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_SYSTEM_ALLOCATION_SCOPE_COMMAND: + dump_enum(settings, "VK_SYSTEM_ALLOCATION_SCOPE_COMMAND", static_cast(object)); + break; + case VK_SYSTEM_ALLOCATION_SCOPE_OBJECT: + dump_enum(settings, "VK_SYSTEM_ALLOCATION_SCOPE_OBJECT", static_cast(object)); + break; + case VK_SYSTEM_ALLOCATION_SCOPE_CACHE: + dump_enum(settings, "VK_SYSTEM_ALLOCATION_SCOPE_CACHE", static_cast(object)); + break; + case VK_SYSTEM_ALLOCATION_SCOPE_DEVICE: + dump_enum(settings, "VK_SYSTEM_ALLOCATION_SCOPE_DEVICE", static_cast(object)); + break; + case VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE: + dump_enum(settings, "VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkInternalAllocationType(const VkInternalAllocationType object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE: + dump_enum(settings, "VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkFormat(const VkFormat object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_FORMAT_UNDEFINED: + dump_enum(settings, "VK_FORMAT_UNDEFINED", static_cast(object)); + break; + case VK_FORMAT_R4G4_UNORM_PACK8: + dump_enum(settings, "VK_FORMAT_R4G4_UNORM_PACK8", static_cast(object)); + break; + case VK_FORMAT_R4G4B4A4_UNORM_PACK16: + dump_enum(settings, "VK_FORMAT_R4G4B4A4_UNORM_PACK16", static_cast(object)); + break; + case VK_FORMAT_B4G4R4A4_UNORM_PACK16: + dump_enum(settings, "VK_FORMAT_B4G4R4A4_UNORM_PACK16", static_cast(object)); + break; + case VK_FORMAT_R5G6B5_UNORM_PACK16: + dump_enum(settings, "VK_FORMAT_R5G6B5_UNORM_PACK16", static_cast(object)); + break; + case VK_FORMAT_B5G6R5_UNORM_PACK16: + dump_enum(settings, "VK_FORMAT_B5G6R5_UNORM_PACK16", static_cast(object)); + break; + case VK_FORMAT_R5G5B5A1_UNORM_PACK16: + dump_enum(settings, "VK_FORMAT_R5G5B5A1_UNORM_PACK16", static_cast(object)); + break; + case VK_FORMAT_B5G5R5A1_UNORM_PACK16: + dump_enum(settings, "VK_FORMAT_B5G5R5A1_UNORM_PACK16", static_cast(object)); + break; + case VK_FORMAT_A1R5G5B5_UNORM_PACK16: + dump_enum(settings, "VK_FORMAT_A1R5G5B5_UNORM_PACK16", static_cast(object)); + break; + case VK_FORMAT_R8_UNORM: + dump_enum(settings, "VK_FORMAT_R8_UNORM", static_cast(object)); + break; + case VK_FORMAT_R8_SNORM: + dump_enum(settings, "VK_FORMAT_R8_SNORM", static_cast(object)); + break; + case VK_FORMAT_R8_USCALED: + dump_enum(settings, "VK_FORMAT_R8_USCALED", static_cast(object)); + break; + case VK_FORMAT_R8_SSCALED: + dump_enum(settings, "VK_FORMAT_R8_SSCALED", static_cast(object)); + break; + case VK_FORMAT_R8_UINT: + dump_enum(settings, "VK_FORMAT_R8_UINT", static_cast(object)); + break; + case VK_FORMAT_R8_SINT: + dump_enum(settings, "VK_FORMAT_R8_SINT", static_cast(object)); + break; + case VK_FORMAT_R8_SRGB: + dump_enum(settings, "VK_FORMAT_R8_SRGB", static_cast(object)); + break; + case VK_FORMAT_R8G8_UNORM: + dump_enum(settings, "VK_FORMAT_R8G8_UNORM", static_cast(object)); + break; + case VK_FORMAT_R8G8_SNORM: + dump_enum(settings, "VK_FORMAT_R8G8_SNORM", static_cast(object)); + break; + case VK_FORMAT_R8G8_USCALED: + dump_enum(settings, "VK_FORMAT_R8G8_USCALED", static_cast(object)); + break; + case VK_FORMAT_R8G8_SSCALED: + dump_enum(settings, "VK_FORMAT_R8G8_SSCALED", static_cast(object)); + break; + case VK_FORMAT_R8G8_UINT: + dump_enum(settings, "VK_FORMAT_R8G8_UINT", static_cast(object)); + break; + case VK_FORMAT_R8G8_SINT: + dump_enum(settings, "VK_FORMAT_R8G8_SINT", static_cast(object)); + break; + case VK_FORMAT_R8G8_SRGB: + dump_enum(settings, "VK_FORMAT_R8G8_SRGB", static_cast(object)); + break; + case VK_FORMAT_R8G8B8_UNORM: + dump_enum(settings, "VK_FORMAT_R8G8B8_UNORM", static_cast(object)); + break; + case VK_FORMAT_R8G8B8_SNORM: + dump_enum(settings, "VK_FORMAT_R8G8B8_SNORM", static_cast(object)); + break; + case VK_FORMAT_R8G8B8_USCALED: + dump_enum(settings, "VK_FORMAT_R8G8B8_USCALED", static_cast(object)); + break; + case VK_FORMAT_R8G8B8_SSCALED: + dump_enum(settings, "VK_FORMAT_R8G8B8_SSCALED", static_cast(object)); + break; + case VK_FORMAT_R8G8B8_UINT: + dump_enum(settings, "VK_FORMAT_R8G8B8_UINT", static_cast(object)); + break; + case VK_FORMAT_R8G8B8_SINT: + dump_enum(settings, "VK_FORMAT_R8G8B8_SINT", static_cast(object)); + break; + case VK_FORMAT_R8G8B8_SRGB: + dump_enum(settings, "VK_FORMAT_R8G8B8_SRGB", static_cast(object)); + break; + case VK_FORMAT_B8G8R8_UNORM: + dump_enum(settings, "VK_FORMAT_B8G8R8_UNORM", static_cast(object)); + break; + case VK_FORMAT_B8G8R8_SNORM: + dump_enum(settings, "VK_FORMAT_B8G8R8_SNORM", static_cast(object)); + break; + case VK_FORMAT_B8G8R8_USCALED: + dump_enum(settings, "VK_FORMAT_B8G8R8_USCALED", static_cast(object)); + break; + case VK_FORMAT_B8G8R8_SSCALED: + dump_enum(settings, "VK_FORMAT_B8G8R8_SSCALED", static_cast(object)); + break; + case VK_FORMAT_B8G8R8_UINT: + dump_enum(settings, "VK_FORMAT_B8G8R8_UINT", static_cast(object)); + break; + case VK_FORMAT_B8G8R8_SINT: + dump_enum(settings, "VK_FORMAT_B8G8R8_SINT", static_cast(object)); + break; + case VK_FORMAT_B8G8R8_SRGB: + dump_enum(settings, "VK_FORMAT_B8G8R8_SRGB", static_cast(object)); + break; + case VK_FORMAT_R8G8B8A8_UNORM: + dump_enum(settings, "VK_FORMAT_R8G8B8A8_UNORM", static_cast(object)); + break; + case VK_FORMAT_R8G8B8A8_SNORM: + dump_enum(settings, "VK_FORMAT_R8G8B8A8_SNORM", static_cast(object)); + break; + case VK_FORMAT_R8G8B8A8_USCALED: + dump_enum(settings, "VK_FORMAT_R8G8B8A8_USCALED", static_cast(object)); + break; + case VK_FORMAT_R8G8B8A8_SSCALED: + dump_enum(settings, "VK_FORMAT_R8G8B8A8_SSCALED", static_cast(object)); + break; + case VK_FORMAT_R8G8B8A8_UINT: + dump_enum(settings, "VK_FORMAT_R8G8B8A8_UINT", static_cast(object)); + break; + case VK_FORMAT_R8G8B8A8_SINT: + dump_enum(settings, "VK_FORMAT_R8G8B8A8_SINT", static_cast(object)); + break; + case VK_FORMAT_R8G8B8A8_SRGB: + dump_enum(settings, "VK_FORMAT_R8G8B8A8_SRGB", static_cast(object)); + break; + case VK_FORMAT_B8G8R8A8_UNORM: + dump_enum(settings, "VK_FORMAT_B8G8R8A8_UNORM", static_cast(object)); + break; + case VK_FORMAT_B8G8R8A8_SNORM: + dump_enum(settings, "VK_FORMAT_B8G8R8A8_SNORM", static_cast(object)); + break; + case VK_FORMAT_B8G8R8A8_USCALED: + dump_enum(settings, "VK_FORMAT_B8G8R8A8_USCALED", static_cast(object)); + break; + case VK_FORMAT_B8G8R8A8_SSCALED: + dump_enum(settings, "VK_FORMAT_B8G8R8A8_SSCALED", static_cast(object)); + break; + case VK_FORMAT_B8G8R8A8_UINT: + dump_enum(settings, "VK_FORMAT_B8G8R8A8_UINT", static_cast(object)); + break; + case VK_FORMAT_B8G8R8A8_SINT: + dump_enum(settings, "VK_FORMAT_B8G8R8A8_SINT", static_cast(object)); + break; + case VK_FORMAT_B8G8R8A8_SRGB: + dump_enum(settings, "VK_FORMAT_B8G8R8A8_SRGB", static_cast(object)); + break; + case VK_FORMAT_A8B8G8R8_UNORM_PACK32: + dump_enum(settings, "VK_FORMAT_A8B8G8R8_UNORM_PACK32", static_cast(object)); + break; + case VK_FORMAT_A8B8G8R8_SNORM_PACK32: + dump_enum(settings, "VK_FORMAT_A8B8G8R8_SNORM_PACK32", static_cast(object)); + break; + case VK_FORMAT_A8B8G8R8_USCALED_PACK32: + dump_enum(settings, "VK_FORMAT_A8B8G8R8_USCALED_PACK32", static_cast(object)); + break; + case VK_FORMAT_A8B8G8R8_SSCALED_PACK32: + dump_enum(settings, "VK_FORMAT_A8B8G8R8_SSCALED_PACK32", static_cast(object)); + break; + case VK_FORMAT_A8B8G8R8_UINT_PACK32: + dump_enum(settings, "VK_FORMAT_A8B8G8R8_UINT_PACK32", static_cast(object)); + break; + case VK_FORMAT_A8B8G8R8_SINT_PACK32: + dump_enum(settings, "VK_FORMAT_A8B8G8R8_SINT_PACK32", static_cast(object)); + break; + case VK_FORMAT_A8B8G8R8_SRGB_PACK32: + dump_enum(settings, "VK_FORMAT_A8B8G8R8_SRGB_PACK32", static_cast(object)); + break; + case VK_FORMAT_A2R10G10B10_UNORM_PACK32: + dump_enum(settings, "VK_FORMAT_A2R10G10B10_UNORM_PACK32", static_cast(object)); + break; + case VK_FORMAT_A2R10G10B10_SNORM_PACK32: + dump_enum(settings, "VK_FORMAT_A2R10G10B10_SNORM_PACK32", static_cast(object)); + break; + case VK_FORMAT_A2R10G10B10_USCALED_PACK32: + dump_enum(settings, "VK_FORMAT_A2R10G10B10_USCALED_PACK32", static_cast(object)); + break; + case VK_FORMAT_A2R10G10B10_SSCALED_PACK32: + dump_enum(settings, "VK_FORMAT_A2R10G10B10_SSCALED_PACK32", static_cast(object)); + break; + case VK_FORMAT_A2R10G10B10_UINT_PACK32: + dump_enum(settings, "VK_FORMAT_A2R10G10B10_UINT_PACK32", static_cast(object)); + break; + case VK_FORMAT_A2R10G10B10_SINT_PACK32: + dump_enum(settings, "VK_FORMAT_A2R10G10B10_SINT_PACK32", static_cast(object)); + break; + case VK_FORMAT_A2B10G10R10_UNORM_PACK32: + dump_enum(settings, "VK_FORMAT_A2B10G10R10_UNORM_PACK32", static_cast(object)); + break; + case VK_FORMAT_A2B10G10R10_SNORM_PACK32: + dump_enum(settings, "VK_FORMAT_A2B10G10R10_SNORM_PACK32", static_cast(object)); + break; + case VK_FORMAT_A2B10G10R10_USCALED_PACK32: + dump_enum(settings, "VK_FORMAT_A2B10G10R10_USCALED_PACK32", static_cast(object)); + break; + case VK_FORMAT_A2B10G10R10_SSCALED_PACK32: + dump_enum(settings, "VK_FORMAT_A2B10G10R10_SSCALED_PACK32", static_cast(object)); + break; + case VK_FORMAT_A2B10G10R10_UINT_PACK32: + dump_enum(settings, "VK_FORMAT_A2B10G10R10_UINT_PACK32", static_cast(object)); + break; + case VK_FORMAT_A2B10G10R10_SINT_PACK32: + dump_enum(settings, "VK_FORMAT_A2B10G10R10_SINT_PACK32", static_cast(object)); + break; + case VK_FORMAT_R16_UNORM: + dump_enum(settings, "VK_FORMAT_R16_UNORM", static_cast(object)); + break; + case VK_FORMAT_R16_SNORM: + dump_enum(settings, "VK_FORMAT_R16_SNORM", static_cast(object)); + break; + case VK_FORMAT_R16_USCALED: + dump_enum(settings, "VK_FORMAT_R16_USCALED", static_cast(object)); + break; + case VK_FORMAT_R16_SSCALED: + dump_enum(settings, "VK_FORMAT_R16_SSCALED", static_cast(object)); + break; + case VK_FORMAT_R16_UINT: + dump_enum(settings, "VK_FORMAT_R16_UINT", static_cast(object)); + break; + case VK_FORMAT_R16_SINT: + dump_enum(settings, "VK_FORMAT_R16_SINT", static_cast(object)); + break; + case VK_FORMAT_R16_SFLOAT: + dump_enum(settings, "VK_FORMAT_R16_SFLOAT", static_cast(object)); + break; + case VK_FORMAT_R16G16_UNORM: + dump_enum(settings, "VK_FORMAT_R16G16_UNORM", static_cast(object)); + break; + case VK_FORMAT_R16G16_SNORM: + dump_enum(settings, "VK_FORMAT_R16G16_SNORM", static_cast(object)); + break; + case VK_FORMAT_R16G16_USCALED: + dump_enum(settings, "VK_FORMAT_R16G16_USCALED", static_cast(object)); + break; + case VK_FORMAT_R16G16_SSCALED: + dump_enum(settings, "VK_FORMAT_R16G16_SSCALED", static_cast(object)); + break; + case VK_FORMAT_R16G16_UINT: + dump_enum(settings, "VK_FORMAT_R16G16_UINT", static_cast(object)); + break; + case VK_FORMAT_R16G16_SINT: + dump_enum(settings, "VK_FORMAT_R16G16_SINT", static_cast(object)); + break; + case VK_FORMAT_R16G16_SFLOAT: + dump_enum(settings, "VK_FORMAT_R16G16_SFLOAT", static_cast(object)); + break; + case VK_FORMAT_R16G16B16_UNORM: + dump_enum(settings, "VK_FORMAT_R16G16B16_UNORM", static_cast(object)); + break; + case VK_FORMAT_R16G16B16_SNORM: + dump_enum(settings, "VK_FORMAT_R16G16B16_SNORM", static_cast(object)); + break; + case VK_FORMAT_R16G16B16_USCALED: + dump_enum(settings, "VK_FORMAT_R16G16B16_USCALED", static_cast(object)); + break; + case VK_FORMAT_R16G16B16_SSCALED: + dump_enum(settings, "VK_FORMAT_R16G16B16_SSCALED", static_cast(object)); + break; + case VK_FORMAT_R16G16B16_UINT: + dump_enum(settings, "VK_FORMAT_R16G16B16_UINT", static_cast(object)); + break; + case VK_FORMAT_R16G16B16_SINT: + dump_enum(settings, "VK_FORMAT_R16G16B16_SINT", static_cast(object)); + break; + case VK_FORMAT_R16G16B16_SFLOAT: + dump_enum(settings, "VK_FORMAT_R16G16B16_SFLOAT", static_cast(object)); + break; + case VK_FORMAT_R16G16B16A16_UNORM: + dump_enum(settings, "VK_FORMAT_R16G16B16A16_UNORM", static_cast(object)); + break; + case VK_FORMAT_R16G16B16A16_SNORM: + dump_enum(settings, "VK_FORMAT_R16G16B16A16_SNORM", static_cast(object)); + break; + case VK_FORMAT_R16G16B16A16_USCALED: + dump_enum(settings, "VK_FORMAT_R16G16B16A16_USCALED", static_cast(object)); + break; + case VK_FORMAT_R16G16B16A16_SSCALED: + dump_enum(settings, "VK_FORMAT_R16G16B16A16_SSCALED", static_cast(object)); + break; + case VK_FORMAT_R16G16B16A16_UINT: + dump_enum(settings, "VK_FORMAT_R16G16B16A16_UINT", static_cast(object)); + break; + case VK_FORMAT_R16G16B16A16_SINT: + dump_enum(settings, "VK_FORMAT_R16G16B16A16_SINT", static_cast(object)); + break; + case VK_FORMAT_R16G16B16A16_SFLOAT: + dump_enum(settings, "VK_FORMAT_R16G16B16A16_SFLOAT", static_cast(object)); + break; + case VK_FORMAT_R32_UINT: + dump_enum(settings, "VK_FORMAT_R32_UINT", static_cast(object)); + break; + case VK_FORMAT_R32_SINT: + dump_enum(settings, "VK_FORMAT_R32_SINT", static_cast(object)); + break; + case VK_FORMAT_R32_SFLOAT: + dump_enum(settings, "VK_FORMAT_R32_SFLOAT", static_cast(object)); + break; + case VK_FORMAT_R32G32_UINT: + dump_enum(settings, "VK_FORMAT_R32G32_UINT", static_cast(object)); + break; + case VK_FORMAT_R32G32_SINT: + dump_enum(settings, "VK_FORMAT_R32G32_SINT", static_cast(object)); + break; + case VK_FORMAT_R32G32_SFLOAT: + dump_enum(settings, "VK_FORMAT_R32G32_SFLOAT", static_cast(object)); + break; + case VK_FORMAT_R32G32B32_UINT: + dump_enum(settings, "VK_FORMAT_R32G32B32_UINT", static_cast(object)); + break; + case VK_FORMAT_R32G32B32_SINT: + dump_enum(settings, "VK_FORMAT_R32G32B32_SINT", static_cast(object)); + break; + case VK_FORMAT_R32G32B32_SFLOAT: + dump_enum(settings, "VK_FORMAT_R32G32B32_SFLOAT", static_cast(object)); + break; + case VK_FORMAT_R32G32B32A32_UINT: + dump_enum(settings, "VK_FORMAT_R32G32B32A32_UINT", static_cast(object)); + break; + case VK_FORMAT_R32G32B32A32_SINT: + dump_enum(settings, "VK_FORMAT_R32G32B32A32_SINT", static_cast(object)); + break; + case VK_FORMAT_R32G32B32A32_SFLOAT: + dump_enum(settings, "VK_FORMAT_R32G32B32A32_SFLOAT", static_cast(object)); + break; + case VK_FORMAT_R64_UINT: + dump_enum(settings, "VK_FORMAT_R64_UINT", static_cast(object)); + break; + case VK_FORMAT_R64_SINT: + dump_enum(settings, "VK_FORMAT_R64_SINT", static_cast(object)); + break; + case VK_FORMAT_R64_SFLOAT: + dump_enum(settings, "VK_FORMAT_R64_SFLOAT", static_cast(object)); + break; + case VK_FORMAT_R64G64_UINT: + dump_enum(settings, "VK_FORMAT_R64G64_UINT", static_cast(object)); + break; + case VK_FORMAT_R64G64_SINT: + dump_enum(settings, "VK_FORMAT_R64G64_SINT", static_cast(object)); + break; + case VK_FORMAT_R64G64_SFLOAT: + dump_enum(settings, "VK_FORMAT_R64G64_SFLOAT", static_cast(object)); + break; + case VK_FORMAT_R64G64B64_UINT: + dump_enum(settings, "VK_FORMAT_R64G64B64_UINT", static_cast(object)); + break; + case VK_FORMAT_R64G64B64_SINT: + dump_enum(settings, "VK_FORMAT_R64G64B64_SINT", static_cast(object)); + break; + case VK_FORMAT_R64G64B64_SFLOAT: + dump_enum(settings, "VK_FORMAT_R64G64B64_SFLOAT", static_cast(object)); + break; + case VK_FORMAT_R64G64B64A64_UINT: + dump_enum(settings, "VK_FORMAT_R64G64B64A64_UINT", static_cast(object)); + break; + case VK_FORMAT_R64G64B64A64_SINT: + dump_enum(settings, "VK_FORMAT_R64G64B64A64_SINT", static_cast(object)); + break; + case VK_FORMAT_R64G64B64A64_SFLOAT: + dump_enum(settings, "VK_FORMAT_R64G64B64A64_SFLOAT", static_cast(object)); + break; + case VK_FORMAT_B10G11R11_UFLOAT_PACK32: + dump_enum(settings, "VK_FORMAT_B10G11R11_UFLOAT_PACK32", static_cast(object)); + break; + case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32: + dump_enum(settings, "VK_FORMAT_E5B9G9R9_UFLOAT_PACK32", static_cast(object)); + break; + case VK_FORMAT_D16_UNORM: + dump_enum(settings, "VK_FORMAT_D16_UNORM", static_cast(object)); + break; + case VK_FORMAT_X8_D24_UNORM_PACK32: + dump_enum(settings, "VK_FORMAT_X8_D24_UNORM_PACK32", static_cast(object)); + break; + case VK_FORMAT_D32_SFLOAT: + dump_enum(settings, "VK_FORMAT_D32_SFLOAT", static_cast(object)); + break; + case VK_FORMAT_S8_UINT: + dump_enum(settings, "VK_FORMAT_S8_UINT", static_cast(object)); + break; + case VK_FORMAT_D16_UNORM_S8_UINT: + dump_enum(settings, "VK_FORMAT_D16_UNORM_S8_UINT", static_cast(object)); + break; + case VK_FORMAT_D24_UNORM_S8_UINT: + dump_enum(settings, "VK_FORMAT_D24_UNORM_S8_UINT", static_cast(object)); + break; + case VK_FORMAT_D32_SFLOAT_S8_UINT: + dump_enum(settings, "VK_FORMAT_D32_SFLOAT_S8_UINT", static_cast(object)); + break; + case VK_FORMAT_BC1_RGB_UNORM_BLOCK: + dump_enum(settings, "VK_FORMAT_BC1_RGB_UNORM_BLOCK", static_cast(object)); + break; + case VK_FORMAT_BC1_RGB_SRGB_BLOCK: + dump_enum(settings, "VK_FORMAT_BC1_RGB_SRGB_BLOCK", static_cast(object)); + break; + case VK_FORMAT_BC1_RGBA_UNORM_BLOCK: + dump_enum(settings, "VK_FORMAT_BC1_RGBA_UNORM_BLOCK", static_cast(object)); + break; + case VK_FORMAT_BC1_RGBA_SRGB_BLOCK: + dump_enum(settings, "VK_FORMAT_BC1_RGBA_SRGB_BLOCK", static_cast(object)); + break; + case VK_FORMAT_BC2_UNORM_BLOCK: + dump_enum(settings, "VK_FORMAT_BC2_UNORM_BLOCK", static_cast(object)); + break; + case VK_FORMAT_BC2_SRGB_BLOCK: + dump_enum(settings, "VK_FORMAT_BC2_SRGB_BLOCK", static_cast(object)); + break; + case VK_FORMAT_BC3_UNORM_BLOCK: + dump_enum(settings, "VK_FORMAT_BC3_UNORM_BLOCK", static_cast(object)); + break; + case VK_FORMAT_BC3_SRGB_BLOCK: + dump_enum(settings, "VK_FORMAT_BC3_SRGB_BLOCK", static_cast(object)); + break; + case VK_FORMAT_BC4_UNORM_BLOCK: + dump_enum(settings, "VK_FORMAT_BC4_UNORM_BLOCK", static_cast(object)); + break; + case VK_FORMAT_BC4_SNORM_BLOCK: + dump_enum(settings, "VK_FORMAT_BC4_SNORM_BLOCK", static_cast(object)); + break; + case VK_FORMAT_BC5_UNORM_BLOCK: + dump_enum(settings, "VK_FORMAT_BC5_UNORM_BLOCK", static_cast(object)); + break; + case VK_FORMAT_BC5_SNORM_BLOCK: + dump_enum(settings, "VK_FORMAT_BC5_SNORM_BLOCK", static_cast(object)); + break; + case VK_FORMAT_BC6H_UFLOAT_BLOCK: + dump_enum(settings, "VK_FORMAT_BC6H_UFLOAT_BLOCK", static_cast(object)); + break; + case VK_FORMAT_BC6H_SFLOAT_BLOCK: + dump_enum(settings, "VK_FORMAT_BC6H_SFLOAT_BLOCK", static_cast(object)); + break; + case VK_FORMAT_BC7_UNORM_BLOCK: + dump_enum(settings, "VK_FORMAT_BC7_UNORM_BLOCK", static_cast(object)); + break; + case VK_FORMAT_BC7_SRGB_BLOCK: + dump_enum(settings, "VK_FORMAT_BC7_SRGB_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK: + dump_enum(settings, "VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK: + dump_enum(settings, "VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK: + dump_enum(settings, "VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK: + dump_enum(settings, "VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK: + dump_enum(settings, "VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK: + dump_enum(settings, "VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK", static_cast(object)); + break; + case VK_FORMAT_EAC_R11_UNORM_BLOCK: + dump_enum(settings, "VK_FORMAT_EAC_R11_UNORM_BLOCK", static_cast(object)); + break; + case VK_FORMAT_EAC_R11_SNORM_BLOCK: + dump_enum(settings, "VK_FORMAT_EAC_R11_SNORM_BLOCK", static_cast(object)); + break; + case VK_FORMAT_EAC_R11G11_UNORM_BLOCK: + dump_enum(settings, "VK_FORMAT_EAC_R11G11_UNORM_BLOCK", static_cast(object)); + break; + case VK_FORMAT_EAC_R11G11_SNORM_BLOCK: + dump_enum(settings, "VK_FORMAT_EAC_R11G11_SNORM_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ASTC_4x4_UNORM_BLOCK: + dump_enum(settings, "VK_FORMAT_ASTC_4x4_UNORM_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ASTC_4x4_SRGB_BLOCK: + dump_enum(settings, "VK_FORMAT_ASTC_4x4_SRGB_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ASTC_5x4_UNORM_BLOCK: + dump_enum(settings, "VK_FORMAT_ASTC_5x4_UNORM_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ASTC_5x4_SRGB_BLOCK: + dump_enum(settings, "VK_FORMAT_ASTC_5x4_SRGB_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ASTC_5x5_UNORM_BLOCK: + dump_enum(settings, "VK_FORMAT_ASTC_5x5_UNORM_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ASTC_5x5_SRGB_BLOCK: + dump_enum(settings, "VK_FORMAT_ASTC_5x5_SRGB_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ASTC_6x5_UNORM_BLOCK: + dump_enum(settings, "VK_FORMAT_ASTC_6x5_UNORM_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ASTC_6x5_SRGB_BLOCK: + dump_enum(settings, "VK_FORMAT_ASTC_6x5_SRGB_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ASTC_6x6_UNORM_BLOCK: + dump_enum(settings, "VK_FORMAT_ASTC_6x6_UNORM_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ASTC_6x6_SRGB_BLOCK: + dump_enum(settings, "VK_FORMAT_ASTC_6x6_SRGB_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ASTC_8x5_UNORM_BLOCK: + dump_enum(settings, "VK_FORMAT_ASTC_8x5_UNORM_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ASTC_8x5_SRGB_BLOCK: + dump_enum(settings, "VK_FORMAT_ASTC_8x5_SRGB_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ASTC_8x6_UNORM_BLOCK: + dump_enum(settings, "VK_FORMAT_ASTC_8x6_UNORM_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ASTC_8x6_SRGB_BLOCK: + dump_enum(settings, "VK_FORMAT_ASTC_8x6_SRGB_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ASTC_8x8_UNORM_BLOCK: + dump_enum(settings, "VK_FORMAT_ASTC_8x8_UNORM_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ASTC_8x8_SRGB_BLOCK: + dump_enum(settings, "VK_FORMAT_ASTC_8x8_SRGB_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ASTC_10x5_UNORM_BLOCK: + dump_enum(settings, "VK_FORMAT_ASTC_10x5_UNORM_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ASTC_10x5_SRGB_BLOCK: + dump_enum(settings, "VK_FORMAT_ASTC_10x5_SRGB_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ASTC_10x6_UNORM_BLOCK: + dump_enum(settings, "VK_FORMAT_ASTC_10x6_UNORM_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ASTC_10x6_SRGB_BLOCK: + dump_enum(settings, "VK_FORMAT_ASTC_10x6_SRGB_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ASTC_10x8_UNORM_BLOCK: + dump_enum(settings, "VK_FORMAT_ASTC_10x8_UNORM_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ASTC_10x8_SRGB_BLOCK: + dump_enum(settings, "VK_FORMAT_ASTC_10x8_SRGB_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ASTC_10x10_UNORM_BLOCK: + dump_enum(settings, "VK_FORMAT_ASTC_10x10_UNORM_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ASTC_10x10_SRGB_BLOCK: + dump_enum(settings, "VK_FORMAT_ASTC_10x10_SRGB_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ASTC_12x10_UNORM_BLOCK: + dump_enum(settings, "VK_FORMAT_ASTC_12x10_UNORM_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ASTC_12x10_SRGB_BLOCK: + dump_enum(settings, "VK_FORMAT_ASTC_12x10_SRGB_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ASTC_12x12_UNORM_BLOCK: + dump_enum(settings, "VK_FORMAT_ASTC_12x12_UNORM_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ASTC_12x12_SRGB_BLOCK: + dump_enum(settings, "VK_FORMAT_ASTC_12x12_SRGB_BLOCK", static_cast(object)); + break; + case VK_FORMAT_G8B8G8R8_422_UNORM: + dump_enum(settings, "VK_FORMAT_G8B8G8R8_422_UNORM", static_cast(object)); + break; + case VK_FORMAT_B8G8R8G8_422_UNORM: + dump_enum(settings, "VK_FORMAT_B8G8R8G8_422_UNORM", static_cast(object)); + break; + case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM: + dump_enum(settings, "VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM", static_cast(object)); + break; + case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM: + dump_enum(settings, "VK_FORMAT_G8_B8R8_2PLANE_420_UNORM", static_cast(object)); + break; + case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM: + dump_enum(settings, "VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM", static_cast(object)); + break; + case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM: + dump_enum(settings, "VK_FORMAT_G8_B8R8_2PLANE_422_UNORM", static_cast(object)); + break; + case VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM: + dump_enum(settings, "VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM", static_cast(object)); + break; + case VK_FORMAT_R10X6_UNORM_PACK16: + dump_enum(settings, "VK_FORMAT_R10X6_UNORM_PACK16", static_cast(object)); + break; + case VK_FORMAT_R10X6G10X6_UNORM_2PACK16: + dump_enum(settings, "VK_FORMAT_R10X6G10X6_UNORM_2PACK16", static_cast(object)); + break; + case VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16: + dump_enum(settings, "VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16", static_cast(object)); + break; + case VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16: + dump_enum(settings, "VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16", static_cast(object)); + break; + case VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16: + dump_enum(settings, "VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16", static_cast(object)); + break; + case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16: + dump_enum(settings, "VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16", static_cast(object)); + break; + case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16: + dump_enum(settings, "VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16", static_cast(object)); + break; + case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16: + dump_enum(settings, "VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16", static_cast(object)); + break; + case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16: + dump_enum(settings, "VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16", static_cast(object)); + break; + case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16: + dump_enum(settings, "VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16", static_cast(object)); + break; + case VK_FORMAT_R12X4_UNORM_PACK16: + dump_enum(settings, "VK_FORMAT_R12X4_UNORM_PACK16", static_cast(object)); + break; + case VK_FORMAT_R12X4G12X4_UNORM_2PACK16: + dump_enum(settings, "VK_FORMAT_R12X4G12X4_UNORM_2PACK16", static_cast(object)); + break; + case VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16: + dump_enum(settings, "VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16", static_cast(object)); + break; + case VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16: + dump_enum(settings, "VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16", static_cast(object)); + break; + case VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16: + dump_enum(settings, "VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16", static_cast(object)); + break; + case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16: + dump_enum(settings, "VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16", static_cast(object)); + break; + case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16: + dump_enum(settings, "VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16", static_cast(object)); + break; + case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16: + dump_enum(settings, "VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16", static_cast(object)); + break; + case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16: + dump_enum(settings, "VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16", static_cast(object)); + break; + case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16: + dump_enum(settings, "VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16", static_cast(object)); + break; + case VK_FORMAT_G16B16G16R16_422_UNORM: + dump_enum(settings, "VK_FORMAT_G16B16G16R16_422_UNORM", static_cast(object)); + break; + case VK_FORMAT_B16G16R16G16_422_UNORM: + dump_enum(settings, "VK_FORMAT_B16G16R16G16_422_UNORM", static_cast(object)); + break; + case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM: + dump_enum(settings, "VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM", static_cast(object)); + break; + case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM: + dump_enum(settings, "VK_FORMAT_G16_B16R16_2PLANE_420_UNORM", static_cast(object)); + break; + case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM: + dump_enum(settings, "VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM", static_cast(object)); + break; + case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM: + dump_enum(settings, "VK_FORMAT_G16_B16R16_2PLANE_422_UNORM", static_cast(object)); + break; + case VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM: + dump_enum(settings, "VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM", static_cast(object)); + break; + case VK_FORMAT_G8_B8R8_2PLANE_444_UNORM: + dump_enum(settings, "VK_FORMAT_G8_B8R8_2PLANE_444_UNORM", static_cast(object)); + break; + case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16: + dump_enum(settings, "VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16", static_cast(object)); + break; + case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16: + dump_enum(settings, "VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16", static_cast(object)); + break; + case VK_FORMAT_G16_B16R16_2PLANE_444_UNORM: + dump_enum(settings, "VK_FORMAT_G16_B16R16_2PLANE_444_UNORM", static_cast(object)); + break; + case VK_FORMAT_A4R4G4B4_UNORM_PACK16: + dump_enum(settings, "VK_FORMAT_A4R4G4B4_UNORM_PACK16", static_cast(object)); + break; + case VK_FORMAT_A4B4G4R4_UNORM_PACK16: + dump_enum(settings, "VK_FORMAT_A4B4G4R4_UNORM_PACK16", static_cast(object)); + break; + case VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK: + dump_enum(settings, "VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK: + dump_enum(settings, "VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK: + dump_enum(settings, "VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK: + dump_enum(settings, "VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK: + dump_enum(settings, "VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK: + dump_enum(settings, "VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK: + dump_enum(settings, "VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK: + dump_enum(settings, "VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK: + dump_enum(settings, "VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK: + dump_enum(settings, "VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK: + dump_enum(settings, "VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK: + dump_enum(settings, "VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK: + dump_enum(settings, "VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK", static_cast(object)); + break; + case VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK: + dump_enum(settings, "VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK", static_cast(object)); + break; + case VK_FORMAT_A1B5G5R5_UNORM_PACK16: + dump_enum(settings, "VK_FORMAT_A1B5G5R5_UNORM_PACK16", static_cast(object)); + break; + case VK_FORMAT_A8_UNORM: + dump_enum(settings, "VK_FORMAT_A8_UNORM", static_cast(object)); + break; + case VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG: + dump_enum(settings, "VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG", static_cast(object)); + break; + case VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG: + dump_enum(settings, "VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG", static_cast(object)); + break; + case VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG: + dump_enum(settings, "VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG", static_cast(object)); + break; + case VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG: + dump_enum(settings, "VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG", static_cast(object)); + break; + case VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG: + dump_enum(settings, "VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG", static_cast(object)); + break; + case VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG: + dump_enum(settings, "VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG", static_cast(object)); + break; + case VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG: + dump_enum(settings, "VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG", static_cast(object)); + break; + case VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG: + dump_enum(settings, "VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG", static_cast(object)); + break; + case VK_FORMAT_ASTC_3x3x3_UNORM_BLOCK_EXT: + dump_enum(settings, "VK_FORMAT_ASTC_3x3x3_UNORM_BLOCK_EXT", static_cast(object)); + break; + case VK_FORMAT_ASTC_3x3x3_SRGB_BLOCK_EXT: + dump_enum(settings, "VK_FORMAT_ASTC_3x3x3_SRGB_BLOCK_EXT", static_cast(object)); + break; + case VK_FORMAT_ASTC_3x3x3_SFLOAT_BLOCK_EXT: + dump_enum(settings, "VK_FORMAT_ASTC_3x3x3_SFLOAT_BLOCK_EXT", static_cast(object)); + break; + case VK_FORMAT_ASTC_4x3x3_UNORM_BLOCK_EXT: + dump_enum(settings, "VK_FORMAT_ASTC_4x3x3_UNORM_BLOCK_EXT", static_cast(object)); + break; + case VK_FORMAT_ASTC_4x3x3_SRGB_BLOCK_EXT: + dump_enum(settings, "VK_FORMAT_ASTC_4x3x3_SRGB_BLOCK_EXT", static_cast(object)); + break; + case VK_FORMAT_ASTC_4x3x3_SFLOAT_BLOCK_EXT: + dump_enum(settings, "VK_FORMAT_ASTC_4x3x3_SFLOAT_BLOCK_EXT", static_cast(object)); + break; + case VK_FORMAT_ASTC_4x4x3_UNORM_BLOCK_EXT: + dump_enum(settings, "VK_FORMAT_ASTC_4x4x3_UNORM_BLOCK_EXT", static_cast(object)); + break; + case VK_FORMAT_ASTC_4x4x3_SRGB_BLOCK_EXT: + dump_enum(settings, "VK_FORMAT_ASTC_4x4x3_SRGB_BLOCK_EXT", static_cast(object)); + break; + case VK_FORMAT_ASTC_4x4x3_SFLOAT_BLOCK_EXT: + dump_enum(settings, "VK_FORMAT_ASTC_4x4x3_SFLOAT_BLOCK_EXT", static_cast(object)); + break; + case VK_FORMAT_ASTC_4x4x4_UNORM_BLOCK_EXT: + dump_enum(settings, "VK_FORMAT_ASTC_4x4x4_UNORM_BLOCK_EXT", static_cast(object)); + break; + case VK_FORMAT_ASTC_4x4x4_SRGB_BLOCK_EXT: + dump_enum(settings, "VK_FORMAT_ASTC_4x4x4_SRGB_BLOCK_EXT", static_cast(object)); + break; + case VK_FORMAT_ASTC_4x4x4_SFLOAT_BLOCK_EXT: + dump_enum(settings, "VK_FORMAT_ASTC_4x4x4_SFLOAT_BLOCK_EXT", static_cast(object)); + break; + case VK_FORMAT_ASTC_5x4x4_UNORM_BLOCK_EXT: + dump_enum(settings, "VK_FORMAT_ASTC_5x4x4_UNORM_BLOCK_EXT", static_cast(object)); + break; + case VK_FORMAT_ASTC_5x4x4_SRGB_BLOCK_EXT: + dump_enum(settings, "VK_FORMAT_ASTC_5x4x4_SRGB_BLOCK_EXT", static_cast(object)); + break; + case VK_FORMAT_ASTC_5x4x4_SFLOAT_BLOCK_EXT: + dump_enum(settings, "VK_FORMAT_ASTC_5x4x4_SFLOAT_BLOCK_EXT", static_cast(object)); + break; + case VK_FORMAT_ASTC_5x5x4_UNORM_BLOCK_EXT: + dump_enum(settings, "VK_FORMAT_ASTC_5x5x4_UNORM_BLOCK_EXT", static_cast(object)); + break; + case VK_FORMAT_ASTC_5x5x4_SRGB_BLOCK_EXT: + dump_enum(settings, "VK_FORMAT_ASTC_5x5x4_SRGB_BLOCK_EXT", static_cast(object)); + break; + case VK_FORMAT_ASTC_5x5x4_SFLOAT_BLOCK_EXT: + dump_enum(settings, "VK_FORMAT_ASTC_5x5x4_SFLOAT_BLOCK_EXT", static_cast(object)); + break; + case VK_FORMAT_ASTC_5x5x5_UNORM_BLOCK_EXT: + dump_enum(settings, "VK_FORMAT_ASTC_5x5x5_UNORM_BLOCK_EXT", static_cast(object)); + break; + case VK_FORMAT_ASTC_5x5x5_SRGB_BLOCK_EXT: + dump_enum(settings, "VK_FORMAT_ASTC_5x5x5_SRGB_BLOCK_EXT", static_cast(object)); + break; + case VK_FORMAT_ASTC_5x5x5_SFLOAT_BLOCK_EXT: + dump_enum(settings, "VK_FORMAT_ASTC_5x5x5_SFLOAT_BLOCK_EXT", static_cast(object)); + break; + case VK_FORMAT_ASTC_6x5x5_UNORM_BLOCK_EXT: + dump_enum(settings, "VK_FORMAT_ASTC_6x5x5_UNORM_BLOCK_EXT", static_cast(object)); + break; + case VK_FORMAT_ASTC_6x5x5_SRGB_BLOCK_EXT: + dump_enum(settings, "VK_FORMAT_ASTC_6x5x5_SRGB_BLOCK_EXT", static_cast(object)); + break; + case VK_FORMAT_ASTC_6x5x5_SFLOAT_BLOCK_EXT: + dump_enum(settings, "VK_FORMAT_ASTC_6x5x5_SFLOAT_BLOCK_EXT", static_cast(object)); + break; + case VK_FORMAT_ASTC_6x6x5_UNORM_BLOCK_EXT: + dump_enum(settings, "VK_FORMAT_ASTC_6x6x5_UNORM_BLOCK_EXT", static_cast(object)); + break; + case VK_FORMAT_ASTC_6x6x5_SRGB_BLOCK_EXT: + dump_enum(settings, "VK_FORMAT_ASTC_6x6x5_SRGB_BLOCK_EXT", static_cast(object)); + break; + case VK_FORMAT_ASTC_6x6x5_SFLOAT_BLOCK_EXT: + dump_enum(settings, "VK_FORMAT_ASTC_6x6x5_SFLOAT_BLOCK_EXT", static_cast(object)); + break; + case VK_FORMAT_ASTC_6x6x6_UNORM_BLOCK_EXT: + dump_enum(settings, "VK_FORMAT_ASTC_6x6x6_UNORM_BLOCK_EXT", static_cast(object)); + break; + case VK_FORMAT_ASTC_6x6x6_SRGB_BLOCK_EXT: + dump_enum(settings, "VK_FORMAT_ASTC_6x6x6_SRGB_BLOCK_EXT", static_cast(object)); + break; + case VK_FORMAT_ASTC_6x6x6_SFLOAT_BLOCK_EXT: + dump_enum(settings, "VK_FORMAT_ASTC_6x6x6_SFLOAT_BLOCK_EXT", static_cast(object)); + break; + case VK_FORMAT_R8_BOOL_ARM: + dump_enum(settings, "VK_FORMAT_R8_BOOL_ARM", static_cast(object)); + break; + case VK_FORMAT_R16G16_SFIXED5_NV: + dump_enum(settings, "VK_FORMAT_R16G16_SFIXED5_NV", static_cast(object)); + break; + case VK_FORMAT_R10X6_UINT_PACK16_ARM: + dump_enum(settings, "VK_FORMAT_R10X6_UINT_PACK16_ARM", static_cast(object)); + break; + case VK_FORMAT_R10X6G10X6_UINT_2PACK16_ARM: + dump_enum(settings, "VK_FORMAT_R10X6G10X6_UINT_2PACK16_ARM", static_cast(object)); + break; + case VK_FORMAT_R10X6G10X6B10X6A10X6_UINT_4PACK16_ARM: + dump_enum(settings, "VK_FORMAT_R10X6G10X6B10X6A10X6_UINT_4PACK16_ARM", static_cast(object)); + break; + case VK_FORMAT_R12X4_UINT_PACK16_ARM: + dump_enum(settings, "VK_FORMAT_R12X4_UINT_PACK16_ARM", static_cast(object)); + break; + case VK_FORMAT_R12X4G12X4_UINT_2PACK16_ARM: + dump_enum(settings, "VK_FORMAT_R12X4G12X4_UINT_2PACK16_ARM", static_cast(object)); + break; + case VK_FORMAT_R12X4G12X4B12X4A12X4_UINT_4PACK16_ARM: + dump_enum(settings, "VK_FORMAT_R12X4G12X4B12X4A12X4_UINT_4PACK16_ARM", static_cast(object)); + break; + case VK_FORMAT_R14X2_UINT_PACK16_ARM: + dump_enum(settings, "VK_FORMAT_R14X2_UINT_PACK16_ARM", static_cast(object)); + break; + case VK_FORMAT_R14X2G14X2_UINT_2PACK16_ARM: + dump_enum(settings, "VK_FORMAT_R14X2G14X2_UINT_2PACK16_ARM", static_cast(object)); + break; + case VK_FORMAT_R14X2G14X2B14X2A14X2_UINT_4PACK16_ARM: + dump_enum(settings, "VK_FORMAT_R14X2G14X2B14X2A14X2_UINT_4PACK16_ARM", static_cast(object)); + break; + case VK_FORMAT_R14X2_UNORM_PACK16_ARM: + dump_enum(settings, "VK_FORMAT_R14X2_UNORM_PACK16_ARM", static_cast(object)); + break; + case VK_FORMAT_R14X2G14X2_UNORM_2PACK16_ARM: + dump_enum(settings, "VK_FORMAT_R14X2G14X2_UNORM_2PACK16_ARM", static_cast(object)); + break; + case VK_FORMAT_R14X2G14X2B14X2A14X2_UNORM_4PACK16_ARM: + dump_enum(settings, "VK_FORMAT_R14X2G14X2B14X2A14X2_UNORM_4PACK16_ARM", static_cast(object)); + break; + case VK_FORMAT_G14X2_B14X2R14X2_2PLANE_420_UNORM_3PACK16_ARM: + dump_enum(settings, "VK_FORMAT_G14X2_B14X2R14X2_2PLANE_420_UNORM_3PACK16_ARM", static_cast(object)); + break; + case VK_FORMAT_G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16_ARM: + dump_enum(settings, "VK_FORMAT_G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16_ARM", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkImageTiling(const VkImageTiling object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_IMAGE_TILING_OPTIMAL: + dump_enum(settings, "VK_IMAGE_TILING_OPTIMAL", static_cast(object)); + break; + case VK_IMAGE_TILING_LINEAR: + dump_enum(settings, "VK_IMAGE_TILING_LINEAR", static_cast(object)); + break; + case VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT: + dump_enum(settings, "VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkImageType(const VkImageType object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_IMAGE_TYPE_1D: + dump_enum(settings, "VK_IMAGE_TYPE_1D", static_cast(object)); + break; + case VK_IMAGE_TYPE_2D: + dump_enum(settings, "VK_IMAGE_TYPE_2D", static_cast(object)); + break; + case VK_IMAGE_TYPE_3D: + dump_enum(settings, "VK_IMAGE_TYPE_3D", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkPhysicalDeviceType(const VkPhysicalDeviceType object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_PHYSICAL_DEVICE_TYPE_OTHER: + dump_enum(settings, "VK_PHYSICAL_DEVICE_TYPE_OTHER", static_cast(object)); + break; + case VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU: + dump_enum(settings, "VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU", static_cast(object)); + break; + case VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU: + dump_enum(settings, "VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU", static_cast(object)); + break; + case VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU: + dump_enum(settings, "VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU", static_cast(object)); + break; + case VK_PHYSICAL_DEVICE_TYPE_CPU: + dump_enum(settings, "VK_PHYSICAL_DEVICE_TYPE_CPU", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkQueryType(const VkQueryType object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_QUERY_TYPE_OCCLUSION: + dump_enum(settings, "VK_QUERY_TYPE_OCCLUSION", static_cast(object)); + break; + case VK_QUERY_TYPE_PIPELINE_STATISTICS: + dump_enum(settings, "VK_QUERY_TYPE_PIPELINE_STATISTICS", static_cast(object)); + break; + case VK_QUERY_TYPE_TIMESTAMP: + dump_enum(settings, "VK_QUERY_TYPE_TIMESTAMP", static_cast(object)); + break; + case VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR: + dump_enum(settings, "VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR", static_cast(object)); + break; + case VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT: + dump_enum(settings, "VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT", static_cast(object)); + break; + case VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR: + dump_enum(settings, "VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR", static_cast(object)); + break; + case VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR: + dump_enum(settings, "VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR", static_cast(object)); + break; + case VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR: + dump_enum(settings, "VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR", static_cast(object)); + break; + case VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV: + dump_enum(settings, "VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV", static_cast(object)); + break; + case VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL: + dump_enum(settings, "VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL", static_cast(object)); + break; + case VK_QUERY_TYPE_VIDEO_ENCODE_FEEDBACK_KHR: + dump_enum(settings, "VK_QUERY_TYPE_VIDEO_ENCODE_FEEDBACK_KHR", static_cast(object)); + break; + case VK_QUERY_TYPE_MESH_PRIMITIVES_GENERATED_EXT: + dump_enum(settings, "VK_QUERY_TYPE_MESH_PRIMITIVES_GENERATED_EXT", static_cast(object)); + break; + case VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT: + dump_enum(settings, "VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT", static_cast(object)); + break; + case VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR: + dump_enum(settings, "VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR", static_cast(object)); + break; + case VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SIZE_KHR: + dump_enum(settings, "VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SIZE_KHR", static_cast(object)); + break; + case VK_QUERY_TYPE_MICROMAP_SERIALIZATION_SIZE_EXT: + dump_enum(settings, "VK_QUERY_TYPE_MICROMAP_SERIALIZATION_SIZE_EXT", static_cast(object)); + break; + case VK_QUERY_TYPE_MICROMAP_COMPACTED_SIZE_EXT: + dump_enum(settings, "VK_QUERY_TYPE_MICROMAP_COMPACTED_SIZE_EXT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkSharingMode(const VkSharingMode object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_SHARING_MODE_EXCLUSIVE: + dump_enum(settings, "VK_SHARING_MODE_EXCLUSIVE", static_cast(object)); + break; + case VK_SHARING_MODE_CONCURRENT: + dump_enum(settings, "VK_SHARING_MODE_CONCURRENT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkComponentSwizzle(const VkComponentSwizzle object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_COMPONENT_SWIZZLE_IDENTITY: + dump_enum(settings, "VK_COMPONENT_SWIZZLE_IDENTITY", static_cast(object)); + break; + case VK_COMPONENT_SWIZZLE_ZERO: + dump_enum(settings, "VK_COMPONENT_SWIZZLE_ZERO", static_cast(object)); + break; + case VK_COMPONENT_SWIZZLE_ONE: + dump_enum(settings, "VK_COMPONENT_SWIZZLE_ONE", static_cast(object)); + break; + case VK_COMPONENT_SWIZZLE_R: + dump_enum(settings, "VK_COMPONENT_SWIZZLE_R", static_cast(object)); + break; + case VK_COMPONENT_SWIZZLE_G: + dump_enum(settings, "VK_COMPONENT_SWIZZLE_G", static_cast(object)); + break; + case VK_COMPONENT_SWIZZLE_B: + dump_enum(settings, "VK_COMPONENT_SWIZZLE_B", static_cast(object)); + break; + case VK_COMPONENT_SWIZZLE_A: + dump_enum(settings, "VK_COMPONENT_SWIZZLE_A", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkImageViewType(const VkImageViewType object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_IMAGE_VIEW_TYPE_1D: + dump_enum(settings, "VK_IMAGE_VIEW_TYPE_1D", static_cast(object)); + break; + case VK_IMAGE_VIEW_TYPE_2D: + dump_enum(settings, "VK_IMAGE_VIEW_TYPE_2D", static_cast(object)); + break; + case VK_IMAGE_VIEW_TYPE_3D: + dump_enum(settings, "VK_IMAGE_VIEW_TYPE_3D", static_cast(object)); + break; + case VK_IMAGE_VIEW_TYPE_CUBE: + dump_enum(settings, "VK_IMAGE_VIEW_TYPE_CUBE", static_cast(object)); + break; + case VK_IMAGE_VIEW_TYPE_1D_ARRAY: + dump_enum(settings, "VK_IMAGE_VIEW_TYPE_1D_ARRAY", static_cast(object)); + break; + case VK_IMAGE_VIEW_TYPE_2D_ARRAY: + dump_enum(settings, "VK_IMAGE_VIEW_TYPE_2D_ARRAY", static_cast(object)); + break; + case VK_IMAGE_VIEW_TYPE_CUBE_ARRAY: + dump_enum(settings, "VK_IMAGE_VIEW_TYPE_CUBE_ARRAY", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkCommandBufferLevel(const VkCommandBufferLevel object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_COMMAND_BUFFER_LEVEL_PRIMARY: + dump_enum(settings, "VK_COMMAND_BUFFER_LEVEL_PRIMARY", static_cast(object)); + break; + case VK_COMMAND_BUFFER_LEVEL_SECONDARY: + dump_enum(settings, "VK_COMMAND_BUFFER_LEVEL_SECONDARY", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkIndexType(const VkIndexType object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_INDEX_TYPE_UINT16: + dump_enum(settings, "VK_INDEX_TYPE_UINT16", static_cast(object)); + break; + case VK_INDEX_TYPE_UINT32: + dump_enum(settings, "VK_INDEX_TYPE_UINT32", static_cast(object)); + break; + case VK_INDEX_TYPE_UINT8: + dump_enum(settings, "VK_INDEX_TYPE_UINT8", static_cast(object)); + break; + case VK_INDEX_TYPE_NONE_KHR: + dump_enum(settings, "VK_INDEX_TYPE_NONE_KHR", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkPipelineCacheHeaderVersion(const VkPipelineCacheHeaderVersion object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_PIPELINE_CACHE_HEADER_VERSION_ONE: + dump_enum(settings, "VK_PIPELINE_CACHE_HEADER_VERSION_ONE", static_cast(object)); + break; + case VK_PIPELINE_CACHE_HEADER_VERSION_DATA_GRAPH_QCOM: + dump_enum(settings, "VK_PIPELINE_CACHE_HEADER_VERSION_DATA_GRAPH_QCOM", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkBorderColor(const VkBorderColor object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK: + dump_enum(settings, "VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK", static_cast(object)); + break; + case VK_BORDER_COLOR_INT_TRANSPARENT_BLACK: + dump_enum(settings, "VK_BORDER_COLOR_INT_TRANSPARENT_BLACK", static_cast(object)); + break; + case VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK: + dump_enum(settings, "VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK", static_cast(object)); + break; + case VK_BORDER_COLOR_INT_OPAQUE_BLACK: + dump_enum(settings, "VK_BORDER_COLOR_INT_OPAQUE_BLACK", static_cast(object)); + break; + case VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE: + dump_enum(settings, "VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE", static_cast(object)); + break; + case VK_BORDER_COLOR_INT_OPAQUE_WHITE: + dump_enum(settings, "VK_BORDER_COLOR_INT_OPAQUE_WHITE", static_cast(object)); + break; + case VK_BORDER_COLOR_FLOAT_CUSTOM_EXT: + dump_enum(settings, "VK_BORDER_COLOR_FLOAT_CUSTOM_EXT", static_cast(object)); + break; + case VK_BORDER_COLOR_INT_CUSTOM_EXT: + dump_enum(settings, "VK_BORDER_COLOR_INT_CUSTOM_EXT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkFilter(const VkFilter object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_FILTER_NEAREST: + dump_enum(settings, "VK_FILTER_NEAREST", static_cast(object)); + break; + case VK_FILTER_LINEAR: + dump_enum(settings, "VK_FILTER_LINEAR", static_cast(object)); + break; + case VK_FILTER_CUBIC_EXT: + dump_enum(settings, "VK_FILTER_CUBIC_EXT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkSamplerAddressMode(const VkSamplerAddressMode object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_SAMPLER_ADDRESS_MODE_REPEAT: + dump_enum(settings, "VK_SAMPLER_ADDRESS_MODE_REPEAT", static_cast(object)); + break; + case VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT: + dump_enum(settings, "VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT", static_cast(object)); + break; + case VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE: + dump_enum(settings, "VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE", static_cast(object)); + break; + case VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER: + dump_enum(settings, "VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER", static_cast(object)); + break; + case VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE: + dump_enum(settings, "VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkSamplerMipmapMode(const VkSamplerMipmapMode object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_SAMPLER_MIPMAP_MODE_NEAREST: + dump_enum(settings, "VK_SAMPLER_MIPMAP_MODE_NEAREST", static_cast(object)); + break; + case VK_SAMPLER_MIPMAP_MODE_LINEAR: + dump_enum(settings, "VK_SAMPLER_MIPMAP_MODE_LINEAR", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkCompareOp(const VkCompareOp object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_COMPARE_OP_NEVER: + dump_enum(settings, "VK_COMPARE_OP_NEVER", static_cast(object)); + break; + case VK_COMPARE_OP_LESS: + dump_enum(settings, "VK_COMPARE_OP_LESS", static_cast(object)); + break; + case VK_COMPARE_OP_EQUAL: + dump_enum(settings, "VK_COMPARE_OP_EQUAL", static_cast(object)); + break; + case VK_COMPARE_OP_LESS_OR_EQUAL: + dump_enum(settings, "VK_COMPARE_OP_LESS_OR_EQUAL", static_cast(object)); + break; + case VK_COMPARE_OP_GREATER: + dump_enum(settings, "VK_COMPARE_OP_GREATER", static_cast(object)); + break; + case VK_COMPARE_OP_NOT_EQUAL: + dump_enum(settings, "VK_COMPARE_OP_NOT_EQUAL", static_cast(object)); + break; + case VK_COMPARE_OP_GREATER_OR_EQUAL: + dump_enum(settings, "VK_COMPARE_OP_GREATER_OR_EQUAL", static_cast(object)); + break; + case VK_COMPARE_OP_ALWAYS: + dump_enum(settings, "VK_COMPARE_OP_ALWAYS", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkDescriptorType(const VkDescriptorType object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_DESCRIPTOR_TYPE_SAMPLER: + dump_enum(settings, "VK_DESCRIPTOR_TYPE_SAMPLER", static_cast(object)); + break; + case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: + dump_enum(settings, "VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER", static_cast(object)); + break; + case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: + dump_enum(settings, "VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE", static_cast(object)); + break; + case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: + dump_enum(settings, "VK_DESCRIPTOR_TYPE_STORAGE_IMAGE", static_cast(object)); + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: + dump_enum(settings, "VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER", static_cast(object)); + break; + case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: + dump_enum(settings, "VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER", static_cast(object)); + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: + dump_enum(settings, "VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER", static_cast(object)); + break; + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: + dump_enum(settings, "VK_DESCRIPTOR_TYPE_STORAGE_BUFFER", static_cast(object)); + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: + dump_enum(settings, "VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC", static_cast(object)); + break; + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: + dump_enum(settings, "VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC", static_cast(object)); + break; + case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: + dump_enum(settings, "VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT", static_cast(object)); + break; + case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK: + dump_enum(settings, "VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK", static_cast(object)); + break; + case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR: + dump_enum(settings, "VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR", static_cast(object)); + break; + case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV: + dump_enum(settings, "VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV", static_cast(object)); + break; + case VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM: + dump_enum(settings, "VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM", static_cast(object)); + break; + case VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM: + dump_enum(settings, "VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM", static_cast(object)); + break; + case VK_DESCRIPTOR_TYPE_TENSOR_ARM: + dump_enum(settings, "VK_DESCRIPTOR_TYPE_TENSOR_ARM", static_cast(object)); + break; + case VK_DESCRIPTOR_TYPE_MUTABLE_EXT: + dump_enum(settings, "VK_DESCRIPTOR_TYPE_MUTABLE_EXT", static_cast(object)); + break; + case VK_DESCRIPTOR_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_NV: + dump_enum(settings, "VK_DESCRIPTOR_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_NV", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkPipelineBindPoint(const VkPipelineBindPoint object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_PIPELINE_BIND_POINT_GRAPHICS: + dump_enum(settings, "VK_PIPELINE_BIND_POINT_GRAPHICS", static_cast(object)); + break; + case VK_PIPELINE_BIND_POINT_COMPUTE: + dump_enum(settings, "VK_PIPELINE_BIND_POINT_COMPUTE", static_cast(object)); + break; +#if defined(VK_ENABLE_BETA_EXTENSIONS) + case VK_PIPELINE_BIND_POINT_EXECUTION_GRAPH_AMDX: + dump_enum(settings, "VK_PIPELINE_BIND_POINT_EXECUTION_GRAPH_AMDX", static_cast(object)); + break; +#endif // VK_ENABLE_BETA_EXTENSIONS + case VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR: + dump_enum(settings, "VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR", static_cast(object)); + break; + case VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI: + dump_enum(settings, "VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI", static_cast(object)); + break; + case VK_PIPELINE_BIND_POINT_DATA_GRAPH_ARM: + dump_enum(settings, "VK_PIPELINE_BIND_POINT_DATA_GRAPH_ARM", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkBlendFactor(const VkBlendFactor object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_BLEND_FACTOR_ZERO: + dump_enum(settings, "VK_BLEND_FACTOR_ZERO", static_cast(object)); + break; + case VK_BLEND_FACTOR_ONE: + dump_enum(settings, "VK_BLEND_FACTOR_ONE", static_cast(object)); + break; + case VK_BLEND_FACTOR_SRC_COLOR: + dump_enum(settings, "VK_BLEND_FACTOR_SRC_COLOR", static_cast(object)); + break; + case VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR: + dump_enum(settings, "VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR", static_cast(object)); + break; + case VK_BLEND_FACTOR_DST_COLOR: + dump_enum(settings, "VK_BLEND_FACTOR_DST_COLOR", static_cast(object)); + break; + case VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR: + dump_enum(settings, "VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR", static_cast(object)); + break; + case VK_BLEND_FACTOR_SRC_ALPHA: + dump_enum(settings, "VK_BLEND_FACTOR_SRC_ALPHA", static_cast(object)); + break; + case VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA: + dump_enum(settings, "VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA", static_cast(object)); + break; + case VK_BLEND_FACTOR_DST_ALPHA: + dump_enum(settings, "VK_BLEND_FACTOR_DST_ALPHA", static_cast(object)); + break; + case VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA: + dump_enum(settings, "VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA", static_cast(object)); + break; + case VK_BLEND_FACTOR_CONSTANT_COLOR: + dump_enum(settings, "VK_BLEND_FACTOR_CONSTANT_COLOR", static_cast(object)); + break; + case VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR: + dump_enum(settings, "VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR", static_cast(object)); + break; + case VK_BLEND_FACTOR_CONSTANT_ALPHA: + dump_enum(settings, "VK_BLEND_FACTOR_CONSTANT_ALPHA", static_cast(object)); + break; + case VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA: + dump_enum(settings, "VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA", static_cast(object)); + break; + case VK_BLEND_FACTOR_SRC_ALPHA_SATURATE: + dump_enum(settings, "VK_BLEND_FACTOR_SRC_ALPHA_SATURATE", static_cast(object)); + break; + case VK_BLEND_FACTOR_SRC1_COLOR: + dump_enum(settings, "VK_BLEND_FACTOR_SRC1_COLOR", static_cast(object)); + break; + case VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR: + dump_enum(settings, "VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR", static_cast(object)); + break; + case VK_BLEND_FACTOR_SRC1_ALPHA: + dump_enum(settings, "VK_BLEND_FACTOR_SRC1_ALPHA", static_cast(object)); + break; + case VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA: + dump_enum(settings, "VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkBlendOp(const VkBlendOp object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_BLEND_OP_ADD: + dump_enum(settings, "VK_BLEND_OP_ADD", static_cast(object)); + break; + case VK_BLEND_OP_SUBTRACT: + dump_enum(settings, "VK_BLEND_OP_SUBTRACT", static_cast(object)); + break; + case VK_BLEND_OP_REVERSE_SUBTRACT: + dump_enum(settings, "VK_BLEND_OP_REVERSE_SUBTRACT", static_cast(object)); + break; + case VK_BLEND_OP_MIN: + dump_enum(settings, "VK_BLEND_OP_MIN", static_cast(object)); + break; + case VK_BLEND_OP_MAX: + dump_enum(settings, "VK_BLEND_OP_MAX", static_cast(object)); + break; + case VK_BLEND_OP_ZERO_EXT: + dump_enum(settings, "VK_BLEND_OP_ZERO_EXT", static_cast(object)); + break; + case VK_BLEND_OP_SRC_EXT: + dump_enum(settings, "VK_BLEND_OP_SRC_EXT", static_cast(object)); + break; + case VK_BLEND_OP_DST_EXT: + dump_enum(settings, "VK_BLEND_OP_DST_EXT", static_cast(object)); + break; + case VK_BLEND_OP_SRC_OVER_EXT: + dump_enum(settings, "VK_BLEND_OP_SRC_OVER_EXT", static_cast(object)); + break; + case VK_BLEND_OP_DST_OVER_EXT: + dump_enum(settings, "VK_BLEND_OP_DST_OVER_EXT", static_cast(object)); + break; + case VK_BLEND_OP_SRC_IN_EXT: + dump_enum(settings, "VK_BLEND_OP_SRC_IN_EXT", static_cast(object)); + break; + case VK_BLEND_OP_DST_IN_EXT: + dump_enum(settings, "VK_BLEND_OP_DST_IN_EXT", static_cast(object)); + break; + case VK_BLEND_OP_SRC_OUT_EXT: + dump_enum(settings, "VK_BLEND_OP_SRC_OUT_EXT", static_cast(object)); + break; + case VK_BLEND_OP_DST_OUT_EXT: + dump_enum(settings, "VK_BLEND_OP_DST_OUT_EXT", static_cast(object)); + break; + case VK_BLEND_OP_SRC_ATOP_EXT: + dump_enum(settings, "VK_BLEND_OP_SRC_ATOP_EXT", static_cast(object)); + break; + case VK_BLEND_OP_DST_ATOP_EXT: + dump_enum(settings, "VK_BLEND_OP_DST_ATOP_EXT", static_cast(object)); + break; + case VK_BLEND_OP_XOR_EXT: + dump_enum(settings, "VK_BLEND_OP_XOR_EXT", static_cast(object)); + break; + case VK_BLEND_OP_MULTIPLY_EXT: + dump_enum(settings, "VK_BLEND_OP_MULTIPLY_EXT", static_cast(object)); + break; + case VK_BLEND_OP_SCREEN_EXT: + dump_enum(settings, "VK_BLEND_OP_SCREEN_EXT", static_cast(object)); + break; + case VK_BLEND_OP_OVERLAY_EXT: + dump_enum(settings, "VK_BLEND_OP_OVERLAY_EXT", static_cast(object)); + break; + case VK_BLEND_OP_DARKEN_EXT: + dump_enum(settings, "VK_BLEND_OP_DARKEN_EXT", static_cast(object)); + break; + case VK_BLEND_OP_LIGHTEN_EXT: + dump_enum(settings, "VK_BLEND_OP_LIGHTEN_EXT", static_cast(object)); + break; + case VK_BLEND_OP_COLORDODGE_EXT: + dump_enum(settings, "VK_BLEND_OP_COLORDODGE_EXT", static_cast(object)); + break; + case VK_BLEND_OP_COLORBURN_EXT: + dump_enum(settings, "VK_BLEND_OP_COLORBURN_EXT", static_cast(object)); + break; + case VK_BLEND_OP_HARDLIGHT_EXT: + dump_enum(settings, "VK_BLEND_OP_HARDLIGHT_EXT", static_cast(object)); + break; + case VK_BLEND_OP_SOFTLIGHT_EXT: + dump_enum(settings, "VK_BLEND_OP_SOFTLIGHT_EXT", static_cast(object)); + break; + case VK_BLEND_OP_DIFFERENCE_EXT: + dump_enum(settings, "VK_BLEND_OP_DIFFERENCE_EXT", static_cast(object)); + break; + case VK_BLEND_OP_EXCLUSION_EXT: + dump_enum(settings, "VK_BLEND_OP_EXCLUSION_EXT", static_cast(object)); + break; + case VK_BLEND_OP_INVERT_EXT: + dump_enum(settings, "VK_BLEND_OP_INVERT_EXT", static_cast(object)); + break; + case VK_BLEND_OP_INVERT_RGB_EXT: + dump_enum(settings, "VK_BLEND_OP_INVERT_RGB_EXT", static_cast(object)); + break; + case VK_BLEND_OP_LINEARDODGE_EXT: + dump_enum(settings, "VK_BLEND_OP_LINEARDODGE_EXT", static_cast(object)); + break; + case VK_BLEND_OP_LINEARBURN_EXT: + dump_enum(settings, "VK_BLEND_OP_LINEARBURN_EXT", static_cast(object)); + break; + case VK_BLEND_OP_VIVIDLIGHT_EXT: + dump_enum(settings, "VK_BLEND_OP_VIVIDLIGHT_EXT", static_cast(object)); + break; + case VK_BLEND_OP_LINEARLIGHT_EXT: + dump_enum(settings, "VK_BLEND_OP_LINEARLIGHT_EXT", static_cast(object)); + break; + case VK_BLEND_OP_PINLIGHT_EXT: + dump_enum(settings, "VK_BLEND_OP_PINLIGHT_EXT", static_cast(object)); + break; + case VK_BLEND_OP_HARDMIX_EXT: + dump_enum(settings, "VK_BLEND_OP_HARDMIX_EXT", static_cast(object)); + break; + case VK_BLEND_OP_HSL_HUE_EXT: + dump_enum(settings, "VK_BLEND_OP_HSL_HUE_EXT", static_cast(object)); + break; + case VK_BLEND_OP_HSL_SATURATION_EXT: + dump_enum(settings, "VK_BLEND_OP_HSL_SATURATION_EXT", static_cast(object)); + break; + case VK_BLEND_OP_HSL_COLOR_EXT: + dump_enum(settings, "VK_BLEND_OP_HSL_COLOR_EXT", static_cast(object)); + break; + case VK_BLEND_OP_HSL_LUMINOSITY_EXT: + dump_enum(settings, "VK_BLEND_OP_HSL_LUMINOSITY_EXT", static_cast(object)); + break; + case VK_BLEND_OP_PLUS_EXT: + dump_enum(settings, "VK_BLEND_OP_PLUS_EXT", static_cast(object)); + break; + case VK_BLEND_OP_PLUS_CLAMPED_EXT: + dump_enum(settings, "VK_BLEND_OP_PLUS_CLAMPED_EXT", static_cast(object)); + break; + case VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT: + dump_enum(settings, "VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT", static_cast(object)); + break; + case VK_BLEND_OP_PLUS_DARKER_EXT: + dump_enum(settings, "VK_BLEND_OP_PLUS_DARKER_EXT", static_cast(object)); + break; + case VK_BLEND_OP_MINUS_EXT: + dump_enum(settings, "VK_BLEND_OP_MINUS_EXT", static_cast(object)); + break; + case VK_BLEND_OP_MINUS_CLAMPED_EXT: + dump_enum(settings, "VK_BLEND_OP_MINUS_CLAMPED_EXT", static_cast(object)); + break; + case VK_BLEND_OP_CONTRAST_EXT: + dump_enum(settings, "VK_BLEND_OP_CONTRAST_EXT", static_cast(object)); + break; + case VK_BLEND_OP_INVERT_OVG_EXT: + dump_enum(settings, "VK_BLEND_OP_INVERT_OVG_EXT", static_cast(object)); + break; + case VK_BLEND_OP_RED_EXT: + dump_enum(settings, "VK_BLEND_OP_RED_EXT", static_cast(object)); + break; + case VK_BLEND_OP_GREEN_EXT: + dump_enum(settings, "VK_BLEND_OP_GREEN_EXT", static_cast(object)); + break; + case VK_BLEND_OP_BLUE_EXT: + dump_enum(settings, "VK_BLEND_OP_BLUE_EXT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkDynamicState(const VkDynamicState object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_DYNAMIC_STATE_VIEWPORT: + dump_enum(settings, "VK_DYNAMIC_STATE_VIEWPORT", static_cast(object)); + break; + case VK_DYNAMIC_STATE_SCISSOR: + dump_enum(settings, "VK_DYNAMIC_STATE_SCISSOR", static_cast(object)); + break; + case VK_DYNAMIC_STATE_LINE_WIDTH: + dump_enum(settings, "VK_DYNAMIC_STATE_LINE_WIDTH", static_cast(object)); + break; + case VK_DYNAMIC_STATE_DEPTH_BIAS: + dump_enum(settings, "VK_DYNAMIC_STATE_DEPTH_BIAS", static_cast(object)); + break; + case VK_DYNAMIC_STATE_BLEND_CONSTANTS: + dump_enum(settings, "VK_DYNAMIC_STATE_BLEND_CONSTANTS", static_cast(object)); + break; + case VK_DYNAMIC_STATE_DEPTH_BOUNDS: + dump_enum(settings, "VK_DYNAMIC_STATE_DEPTH_BOUNDS", static_cast(object)); + break; + case VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK: + dump_enum(settings, "VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK", static_cast(object)); + break; + case VK_DYNAMIC_STATE_STENCIL_WRITE_MASK: + dump_enum(settings, "VK_DYNAMIC_STATE_STENCIL_WRITE_MASK", static_cast(object)); + break; + case VK_DYNAMIC_STATE_STENCIL_REFERENCE: + dump_enum(settings, "VK_DYNAMIC_STATE_STENCIL_REFERENCE", static_cast(object)); + break; + case VK_DYNAMIC_STATE_CULL_MODE: + dump_enum(settings, "VK_DYNAMIC_STATE_CULL_MODE", static_cast(object)); + break; + case VK_DYNAMIC_STATE_FRONT_FACE: + dump_enum(settings, "VK_DYNAMIC_STATE_FRONT_FACE", static_cast(object)); + break; + case VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY: + dump_enum(settings, "VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY", static_cast(object)); + break; + case VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT: + dump_enum(settings, "VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT", static_cast(object)); + break; + case VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT: + dump_enum(settings, "VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT", static_cast(object)); + break; + case VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE: + dump_enum(settings, "VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE", static_cast(object)); + break; + case VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE: + dump_enum(settings, "VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE", static_cast(object)); + break; + case VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE: + dump_enum(settings, "VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE", static_cast(object)); + break; + case VK_DYNAMIC_STATE_DEPTH_COMPARE_OP: + dump_enum(settings, "VK_DYNAMIC_STATE_DEPTH_COMPARE_OP", static_cast(object)); + break; + case VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE: + dump_enum(settings, "VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE", static_cast(object)); + break; + case VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE: + dump_enum(settings, "VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE", static_cast(object)); + break; + case VK_DYNAMIC_STATE_STENCIL_OP: + dump_enum(settings, "VK_DYNAMIC_STATE_STENCIL_OP", static_cast(object)); + break; + case VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE: + dump_enum(settings, "VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE", static_cast(object)); + break; + case VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE: + dump_enum(settings, "VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE", static_cast(object)); + break; + case VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE: + dump_enum(settings, "VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE", static_cast(object)); + break; + case VK_DYNAMIC_STATE_LINE_STIPPLE: + dump_enum(settings, "VK_DYNAMIC_STATE_LINE_STIPPLE", static_cast(object)); + break; + case VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV: + dump_enum(settings, "VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV", static_cast(object)); + break; + case VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT: + dump_enum(settings, "VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT", static_cast(object)); + break; + case VK_DYNAMIC_STATE_DISCARD_RECTANGLE_ENABLE_EXT: + dump_enum(settings, "VK_DYNAMIC_STATE_DISCARD_RECTANGLE_ENABLE_EXT", static_cast(object)); + break; + case VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT: + dump_enum(settings, "VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT", static_cast(object)); + break; + case VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT: + dump_enum(settings, "VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT", static_cast(object)); + break; + case VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR: + dump_enum(settings, "VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR", static_cast(object)); + break; + case VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV: + dump_enum(settings, "VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV", static_cast(object)); + break; + case VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV: + dump_enum(settings, "VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV", static_cast(object)); + break; + case VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_ENABLE_NV: + dump_enum(settings, "VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_ENABLE_NV", static_cast(object)); + break; + case VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV: + dump_enum(settings, "VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV", static_cast(object)); + break; + case VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR: + dump_enum(settings, "VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR", static_cast(object)); + break; + case VK_DYNAMIC_STATE_VERTEX_INPUT_EXT: + dump_enum(settings, "VK_DYNAMIC_STATE_VERTEX_INPUT_EXT", static_cast(object)); + break; + case VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT: + dump_enum(settings, "VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT", static_cast(object)); + break; + case VK_DYNAMIC_STATE_LOGIC_OP_EXT: + dump_enum(settings, "VK_DYNAMIC_STATE_LOGIC_OP_EXT", static_cast(object)); + break; + case VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT: + dump_enum(settings, "VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT", static_cast(object)); + break; + case VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT: + dump_enum(settings, "VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT", static_cast(object)); + break; + case VK_DYNAMIC_STATE_POLYGON_MODE_EXT: + dump_enum(settings, "VK_DYNAMIC_STATE_POLYGON_MODE_EXT", static_cast(object)); + break; + case VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT: + dump_enum(settings, "VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT", static_cast(object)); + break; + case VK_DYNAMIC_STATE_SAMPLE_MASK_EXT: + dump_enum(settings, "VK_DYNAMIC_STATE_SAMPLE_MASK_EXT", static_cast(object)); + break; + case VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT: + dump_enum(settings, "VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT", static_cast(object)); + break; + case VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT: + dump_enum(settings, "VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT", static_cast(object)); + break; + case VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT: + dump_enum(settings, "VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT", static_cast(object)); + break; + case VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT: + dump_enum(settings, "VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT", static_cast(object)); + break; + case VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT: + dump_enum(settings, "VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT", static_cast(object)); + break; + case VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT: + dump_enum(settings, "VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT", static_cast(object)); + break; + case VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT: + dump_enum(settings, "VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT", static_cast(object)); + break; + case VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT: + dump_enum(settings, "VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT", static_cast(object)); + break; + case VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT: + dump_enum(settings, "VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT", static_cast(object)); + break; + case VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT: + dump_enum(settings, "VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT", static_cast(object)); + break; + case VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT: + dump_enum(settings, "VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT", static_cast(object)); + break; + case VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT: + dump_enum(settings, "VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT", static_cast(object)); + break; + case VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT: + dump_enum(settings, "VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT", static_cast(object)); + break; + case VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT: + dump_enum(settings, "VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT", static_cast(object)); + break; + case VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT: + dump_enum(settings, "VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT", static_cast(object)); + break; + case VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT: + dump_enum(settings, "VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT", static_cast(object)); + break; + case VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT: + dump_enum(settings, "VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT", static_cast(object)); + break; + case VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV: + dump_enum(settings, "VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV", static_cast(object)); + break; + case VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV: + dump_enum(settings, "VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV", static_cast(object)); + break; + case VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV: + dump_enum(settings, "VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV", static_cast(object)); + break; + case VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV: + dump_enum(settings, "VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV", static_cast(object)); + break; + case VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV: + dump_enum(settings, "VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV", static_cast(object)); + break; + case VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV: + dump_enum(settings, "VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV", static_cast(object)); + break; + case VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV: + dump_enum(settings, "VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV", static_cast(object)); + break; + case VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV: + dump_enum(settings, "VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV", static_cast(object)); + break; + case VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV: + dump_enum(settings, "VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV", static_cast(object)); + break; + case VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV: + dump_enum(settings, "VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV", static_cast(object)); + break; + case VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT: + dump_enum(settings, "VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT", static_cast(object)); + break; + case VK_DYNAMIC_STATE_DEPTH_CLAMP_RANGE_EXT: + dump_enum(settings, "VK_DYNAMIC_STATE_DEPTH_CLAMP_RANGE_EXT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkFrontFace(const VkFrontFace object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_FRONT_FACE_COUNTER_CLOCKWISE: + dump_enum(settings, "VK_FRONT_FACE_COUNTER_CLOCKWISE", static_cast(object)); + break; + case VK_FRONT_FACE_CLOCKWISE: + dump_enum(settings, "VK_FRONT_FACE_CLOCKWISE", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkVertexInputRate(const VkVertexInputRate object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_VERTEX_INPUT_RATE_VERTEX: + dump_enum(settings, "VK_VERTEX_INPUT_RATE_VERTEX", static_cast(object)); + break; + case VK_VERTEX_INPUT_RATE_INSTANCE: + dump_enum(settings, "VK_VERTEX_INPUT_RATE_INSTANCE", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkPrimitiveTopology(const VkPrimitiveTopology object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_PRIMITIVE_TOPOLOGY_POINT_LIST: + dump_enum(settings, "VK_PRIMITIVE_TOPOLOGY_POINT_LIST", static_cast(object)); + break; + case VK_PRIMITIVE_TOPOLOGY_LINE_LIST: + dump_enum(settings, "VK_PRIMITIVE_TOPOLOGY_LINE_LIST", static_cast(object)); + break; + case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP: + dump_enum(settings, "VK_PRIMITIVE_TOPOLOGY_LINE_STRIP", static_cast(object)); + break; + case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST: + dump_enum(settings, "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST", static_cast(object)); + break; + case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP: + dump_enum(settings, "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP", static_cast(object)); + break; + case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN: + dump_enum(settings, "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN", static_cast(object)); + break; + case VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY: + dump_enum(settings, "VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY", static_cast(object)); + break; + case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY: + dump_enum(settings, "VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY", static_cast(object)); + break; + case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY: + dump_enum(settings, "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY", static_cast(object)); + break; + case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY: + dump_enum(settings, "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY", static_cast(object)); + break; + case VK_PRIMITIVE_TOPOLOGY_PATCH_LIST: + dump_enum(settings, "VK_PRIMITIVE_TOPOLOGY_PATCH_LIST", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkPolygonMode(const VkPolygonMode object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_POLYGON_MODE_FILL: + dump_enum(settings, "VK_POLYGON_MODE_FILL", static_cast(object)); + break; + case VK_POLYGON_MODE_LINE: + dump_enum(settings, "VK_POLYGON_MODE_LINE", static_cast(object)); + break; + case VK_POLYGON_MODE_POINT: + dump_enum(settings, "VK_POLYGON_MODE_POINT", static_cast(object)); + break; + case VK_POLYGON_MODE_FILL_RECTANGLE_NV: + dump_enum(settings, "VK_POLYGON_MODE_FILL_RECTANGLE_NV", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkStencilOp(const VkStencilOp object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_STENCIL_OP_KEEP: + dump_enum(settings, "VK_STENCIL_OP_KEEP", static_cast(object)); + break; + case VK_STENCIL_OP_ZERO: + dump_enum(settings, "VK_STENCIL_OP_ZERO", static_cast(object)); + break; + case VK_STENCIL_OP_REPLACE: + dump_enum(settings, "VK_STENCIL_OP_REPLACE", static_cast(object)); + break; + case VK_STENCIL_OP_INCREMENT_AND_CLAMP: + dump_enum(settings, "VK_STENCIL_OP_INCREMENT_AND_CLAMP", static_cast(object)); + break; + case VK_STENCIL_OP_DECREMENT_AND_CLAMP: + dump_enum(settings, "VK_STENCIL_OP_DECREMENT_AND_CLAMP", static_cast(object)); + break; + case VK_STENCIL_OP_INVERT: + dump_enum(settings, "VK_STENCIL_OP_INVERT", static_cast(object)); + break; + case VK_STENCIL_OP_INCREMENT_AND_WRAP: + dump_enum(settings, "VK_STENCIL_OP_INCREMENT_AND_WRAP", static_cast(object)); + break; + case VK_STENCIL_OP_DECREMENT_AND_WRAP: + dump_enum(settings, "VK_STENCIL_OP_DECREMENT_AND_WRAP", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkLogicOp(const VkLogicOp object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_LOGIC_OP_CLEAR: + dump_enum(settings, "VK_LOGIC_OP_CLEAR", static_cast(object)); + break; + case VK_LOGIC_OP_AND: + dump_enum(settings, "VK_LOGIC_OP_AND", static_cast(object)); + break; + case VK_LOGIC_OP_AND_REVERSE: + dump_enum(settings, "VK_LOGIC_OP_AND_REVERSE", static_cast(object)); + break; + case VK_LOGIC_OP_COPY: + dump_enum(settings, "VK_LOGIC_OP_COPY", static_cast(object)); + break; + case VK_LOGIC_OP_AND_INVERTED: + dump_enum(settings, "VK_LOGIC_OP_AND_INVERTED", static_cast(object)); + break; + case VK_LOGIC_OP_NO_OP: + dump_enum(settings, "VK_LOGIC_OP_NO_OP", static_cast(object)); + break; + case VK_LOGIC_OP_XOR: + dump_enum(settings, "VK_LOGIC_OP_XOR", static_cast(object)); + break; + case VK_LOGIC_OP_OR: + dump_enum(settings, "VK_LOGIC_OP_OR", static_cast(object)); + break; + case VK_LOGIC_OP_NOR: + dump_enum(settings, "VK_LOGIC_OP_NOR", static_cast(object)); + break; + case VK_LOGIC_OP_EQUIVALENT: + dump_enum(settings, "VK_LOGIC_OP_EQUIVALENT", static_cast(object)); + break; + case VK_LOGIC_OP_INVERT: + dump_enum(settings, "VK_LOGIC_OP_INVERT", static_cast(object)); + break; + case VK_LOGIC_OP_OR_REVERSE: + dump_enum(settings, "VK_LOGIC_OP_OR_REVERSE", static_cast(object)); + break; + case VK_LOGIC_OP_COPY_INVERTED: + dump_enum(settings, "VK_LOGIC_OP_COPY_INVERTED", static_cast(object)); + break; + case VK_LOGIC_OP_OR_INVERTED: + dump_enum(settings, "VK_LOGIC_OP_OR_INVERTED", static_cast(object)); + break; + case VK_LOGIC_OP_NAND: + dump_enum(settings, "VK_LOGIC_OP_NAND", static_cast(object)); + break; + case VK_LOGIC_OP_SET: + dump_enum(settings, "VK_LOGIC_OP_SET", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkAttachmentLoadOp(const VkAttachmentLoadOp object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_ATTACHMENT_LOAD_OP_LOAD: + dump_enum(settings, "VK_ATTACHMENT_LOAD_OP_LOAD", static_cast(object)); + break; + case VK_ATTACHMENT_LOAD_OP_CLEAR: + dump_enum(settings, "VK_ATTACHMENT_LOAD_OP_CLEAR", static_cast(object)); + break; + case VK_ATTACHMENT_LOAD_OP_DONT_CARE: + dump_enum(settings, "VK_ATTACHMENT_LOAD_OP_DONT_CARE", static_cast(object)); + break; + case VK_ATTACHMENT_LOAD_OP_NONE: + dump_enum(settings, "VK_ATTACHMENT_LOAD_OP_NONE", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkAttachmentStoreOp(const VkAttachmentStoreOp object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_ATTACHMENT_STORE_OP_STORE: + dump_enum(settings, "VK_ATTACHMENT_STORE_OP_STORE", static_cast(object)); + break; + case VK_ATTACHMENT_STORE_OP_DONT_CARE: + dump_enum(settings, "VK_ATTACHMENT_STORE_OP_DONT_CARE", static_cast(object)); + break; + case VK_ATTACHMENT_STORE_OP_NONE: + dump_enum(settings, "VK_ATTACHMENT_STORE_OP_NONE", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkSubpassContents(const VkSubpassContents object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_SUBPASS_CONTENTS_INLINE: + dump_enum(settings, "VK_SUBPASS_CONTENTS_INLINE", static_cast(object)); + break; + case VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS: + dump_enum(settings, "VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS", static_cast(object)); + break; + case VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_KHR: + dump_enum(settings, "VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_KHR", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkDescriptorUpdateTemplateType(const VkDescriptorUpdateTemplateType object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET: + dump_enum(settings, "VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET", static_cast(object)); + break; + case VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS: + dump_enum(settings, "VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkSamplerYcbcrModelConversion(const VkSamplerYcbcrModelConversion object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY: + dump_enum(settings, "VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY", static_cast(object)); + break; + case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY: + dump_enum(settings, "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY", static_cast(object)); + break; + case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709: + dump_enum(settings, "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709", static_cast(object)); + break; + case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601: + dump_enum(settings, "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601", static_cast(object)); + break; + case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020: + dump_enum(settings, "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkSamplerYcbcrRange(const VkSamplerYcbcrRange object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_SAMPLER_YCBCR_RANGE_ITU_FULL: + dump_enum(settings, "VK_SAMPLER_YCBCR_RANGE_ITU_FULL", static_cast(object)); + break; + case VK_SAMPLER_YCBCR_RANGE_ITU_NARROW: + dump_enum(settings, "VK_SAMPLER_YCBCR_RANGE_ITU_NARROW", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkChromaLocation(const VkChromaLocation object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_CHROMA_LOCATION_COSITED_EVEN: + dump_enum(settings, "VK_CHROMA_LOCATION_COSITED_EVEN", static_cast(object)); + break; + case VK_CHROMA_LOCATION_MIDPOINT: + dump_enum(settings, "VK_CHROMA_LOCATION_MIDPOINT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkPointClippingBehavior(const VkPointClippingBehavior object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES: + dump_enum(settings, "VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES", static_cast(object)); + break; + case VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY: + dump_enum(settings, "VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkTessellationDomainOrigin(const VkTessellationDomainOrigin object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT: + dump_enum(settings, "VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT", static_cast(object)); + break; + case VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT: + dump_enum(settings, "VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkDriverId(const VkDriverId object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_DRIVER_ID_AMD_PROPRIETARY: + dump_enum(settings, "VK_DRIVER_ID_AMD_PROPRIETARY", static_cast(object)); + break; + case VK_DRIVER_ID_AMD_OPEN_SOURCE: + dump_enum(settings, "VK_DRIVER_ID_AMD_OPEN_SOURCE", static_cast(object)); + break; + case VK_DRIVER_ID_MESA_RADV: + dump_enum(settings, "VK_DRIVER_ID_MESA_RADV", static_cast(object)); + break; + case VK_DRIVER_ID_NVIDIA_PROPRIETARY: + dump_enum(settings, "VK_DRIVER_ID_NVIDIA_PROPRIETARY", static_cast(object)); + break; + case VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS: + dump_enum(settings, "VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS", static_cast(object)); + break; + case VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA: + dump_enum(settings, "VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA", static_cast(object)); + break; + case VK_DRIVER_ID_IMAGINATION_PROPRIETARY: + dump_enum(settings, "VK_DRIVER_ID_IMAGINATION_PROPRIETARY", static_cast(object)); + break; + case VK_DRIVER_ID_QUALCOMM_PROPRIETARY: + dump_enum(settings, "VK_DRIVER_ID_QUALCOMM_PROPRIETARY", static_cast(object)); + break; + case VK_DRIVER_ID_ARM_PROPRIETARY: + dump_enum(settings, "VK_DRIVER_ID_ARM_PROPRIETARY", static_cast(object)); + break; + case VK_DRIVER_ID_GOOGLE_SWIFTSHADER: + dump_enum(settings, "VK_DRIVER_ID_GOOGLE_SWIFTSHADER", static_cast(object)); + break; + case VK_DRIVER_ID_GGP_PROPRIETARY: + dump_enum(settings, "VK_DRIVER_ID_GGP_PROPRIETARY", static_cast(object)); + break; + case VK_DRIVER_ID_BROADCOM_PROPRIETARY: + dump_enum(settings, "VK_DRIVER_ID_BROADCOM_PROPRIETARY", static_cast(object)); + break; + case VK_DRIVER_ID_MESA_LLVMPIPE: + dump_enum(settings, "VK_DRIVER_ID_MESA_LLVMPIPE", static_cast(object)); + break; + case VK_DRIVER_ID_MOLTENVK: + dump_enum(settings, "VK_DRIVER_ID_MOLTENVK", static_cast(object)); + break; + case VK_DRIVER_ID_COREAVI_PROPRIETARY: + dump_enum(settings, "VK_DRIVER_ID_COREAVI_PROPRIETARY", static_cast(object)); + break; + case VK_DRIVER_ID_JUICE_PROPRIETARY: + dump_enum(settings, "VK_DRIVER_ID_JUICE_PROPRIETARY", static_cast(object)); + break; + case VK_DRIVER_ID_VERISILICON_PROPRIETARY: + dump_enum(settings, "VK_DRIVER_ID_VERISILICON_PROPRIETARY", static_cast(object)); + break; + case VK_DRIVER_ID_MESA_TURNIP: + dump_enum(settings, "VK_DRIVER_ID_MESA_TURNIP", static_cast(object)); + break; + case VK_DRIVER_ID_MESA_V3DV: + dump_enum(settings, "VK_DRIVER_ID_MESA_V3DV", static_cast(object)); + break; + case VK_DRIVER_ID_MESA_PANVK: + dump_enum(settings, "VK_DRIVER_ID_MESA_PANVK", static_cast(object)); + break; + case VK_DRIVER_ID_SAMSUNG_PROPRIETARY: + dump_enum(settings, "VK_DRIVER_ID_SAMSUNG_PROPRIETARY", static_cast(object)); + break; + case VK_DRIVER_ID_MESA_VENUS: + dump_enum(settings, "VK_DRIVER_ID_MESA_VENUS", static_cast(object)); + break; + case VK_DRIVER_ID_MESA_DOZEN: + dump_enum(settings, "VK_DRIVER_ID_MESA_DOZEN", static_cast(object)); + break; + case VK_DRIVER_ID_MESA_NVK: + dump_enum(settings, "VK_DRIVER_ID_MESA_NVK", static_cast(object)); + break; + case VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA: + dump_enum(settings, "VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA", static_cast(object)); + break; + case VK_DRIVER_ID_MESA_HONEYKRISP: + dump_enum(settings, "VK_DRIVER_ID_MESA_HONEYKRISP", static_cast(object)); + break; + case VK_DRIVER_ID_VULKAN_SC_EMULATION_ON_VULKAN: + dump_enum(settings, "VK_DRIVER_ID_VULKAN_SC_EMULATION_ON_VULKAN", static_cast(object)); + break; + case VK_DRIVER_ID_MESA_KOSMICKRISP: + dump_enum(settings, "VK_DRIVER_ID_MESA_KOSMICKRISP", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkShaderFloatControlsIndependence(const VkShaderFloatControlsIndependence object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY: + dump_enum(settings, "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY", static_cast(object)); + break; + case VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL: + dump_enum(settings, "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL", static_cast(object)); + break; + case VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE: + dump_enum(settings, "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkSemaphoreType(const VkSemaphoreType object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_SEMAPHORE_TYPE_BINARY: + dump_enum(settings, "VK_SEMAPHORE_TYPE_BINARY", static_cast(object)); + break; + case VK_SEMAPHORE_TYPE_TIMELINE: + dump_enum(settings, "VK_SEMAPHORE_TYPE_TIMELINE", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkSamplerReductionMode(const VkSamplerReductionMode object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE: + dump_enum(settings, "VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE", static_cast(object)); + break; + case VK_SAMPLER_REDUCTION_MODE_MIN: + dump_enum(settings, "VK_SAMPLER_REDUCTION_MODE_MIN", static_cast(object)); + break; + case VK_SAMPLER_REDUCTION_MODE_MAX: + dump_enum(settings, "VK_SAMPLER_REDUCTION_MODE_MAX", static_cast(object)); + break; + case VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_RANGECLAMP_QCOM: + dump_enum(settings, "VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_RANGECLAMP_QCOM", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkPipelineRobustnessBufferBehavior(const VkPipelineRobustnessBufferBehavior object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT: + dump_enum(settings, "VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT", static_cast(object)); + break; + case VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED: + dump_enum(settings, "VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED", static_cast(object)); + break; + case VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS: + dump_enum(settings, "VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS", static_cast(object)); + break; + case VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2: + dump_enum(settings, "VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkPipelineRobustnessImageBehavior(const VkPipelineRobustnessImageBehavior object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT: + dump_enum(settings, "VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT", static_cast(object)); + break; + case VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED: + dump_enum(settings, "VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED", static_cast(object)); + break; + case VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS: + dump_enum(settings, "VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS", static_cast(object)); + break; + case VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2: + dump_enum(settings, "VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkQueueGlobalPriority(const VkQueueGlobalPriority object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_QUEUE_GLOBAL_PRIORITY_LOW: + dump_enum(settings, "VK_QUEUE_GLOBAL_PRIORITY_LOW", static_cast(object)); + break; + case VK_QUEUE_GLOBAL_PRIORITY_MEDIUM: + dump_enum(settings, "VK_QUEUE_GLOBAL_PRIORITY_MEDIUM", static_cast(object)); + break; + case VK_QUEUE_GLOBAL_PRIORITY_HIGH: + dump_enum(settings, "VK_QUEUE_GLOBAL_PRIORITY_HIGH", static_cast(object)); + break; + case VK_QUEUE_GLOBAL_PRIORITY_REALTIME: + dump_enum(settings, "VK_QUEUE_GLOBAL_PRIORITY_REALTIME", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkLineRasterizationMode(const VkLineRasterizationMode object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_LINE_RASTERIZATION_MODE_DEFAULT: + dump_enum(settings, "VK_LINE_RASTERIZATION_MODE_DEFAULT", static_cast(object)); + break; + case VK_LINE_RASTERIZATION_MODE_RECTANGULAR: + dump_enum(settings, "VK_LINE_RASTERIZATION_MODE_RECTANGULAR", static_cast(object)); + break; + case VK_LINE_RASTERIZATION_MODE_BRESENHAM: + dump_enum(settings, "VK_LINE_RASTERIZATION_MODE_BRESENHAM", static_cast(object)); + break; + case VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH: + dump_enum(settings, "VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkPresentModeKHR(const VkPresentModeKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_PRESENT_MODE_IMMEDIATE_KHR: + dump_enum(settings, "VK_PRESENT_MODE_IMMEDIATE_KHR", static_cast(object)); + break; + case VK_PRESENT_MODE_MAILBOX_KHR: + dump_enum(settings, "VK_PRESENT_MODE_MAILBOX_KHR", static_cast(object)); + break; + case VK_PRESENT_MODE_FIFO_KHR: + dump_enum(settings, "VK_PRESENT_MODE_FIFO_KHR", static_cast(object)); + break; + case VK_PRESENT_MODE_FIFO_RELAXED_KHR: + dump_enum(settings, "VK_PRESENT_MODE_FIFO_RELAXED_KHR", static_cast(object)); + break; + case VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR: + dump_enum(settings, "VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR", static_cast(object)); + break; + case VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR: + dump_enum(settings, "VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR", static_cast(object)); + break; + case VK_PRESENT_MODE_FIFO_LATEST_READY_KHR: + dump_enum(settings, "VK_PRESENT_MODE_FIFO_LATEST_READY_KHR", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkColorSpaceKHR(const VkColorSpaceKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_COLOR_SPACE_SRGB_NONLINEAR_KHR: + dump_enum(settings, "VK_COLOR_SPACE_SRGB_NONLINEAR_KHR", static_cast(object)); + break; + case VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT: + dump_enum(settings, "VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT", static_cast(object)); + break; + case VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT: + dump_enum(settings, "VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT", static_cast(object)); + break; + case VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT: + dump_enum(settings, "VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT", static_cast(object)); + break; + case VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT: + dump_enum(settings, "VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT", static_cast(object)); + break; + case VK_COLOR_SPACE_BT709_LINEAR_EXT: + dump_enum(settings, "VK_COLOR_SPACE_BT709_LINEAR_EXT", static_cast(object)); + break; + case VK_COLOR_SPACE_BT709_NONLINEAR_EXT: + dump_enum(settings, "VK_COLOR_SPACE_BT709_NONLINEAR_EXT", static_cast(object)); + break; + case VK_COLOR_SPACE_BT2020_LINEAR_EXT: + dump_enum(settings, "VK_COLOR_SPACE_BT2020_LINEAR_EXT", static_cast(object)); + break; + case VK_COLOR_SPACE_HDR10_ST2084_EXT: + dump_enum(settings, "VK_COLOR_SPACE_HDR10_ST2084_EXT", static_cast(object)); + break; + case VK_COLOR_SPACE_DOLBYVISION_EXT: + dump_enum(settings, "VK_COLOR_SPACE_DOLBYVISION_EXT", static_cast(object)); + break; + case VK_COLOR_SPACE_HDR10_HLG_EXT: + dump_enum(settings, "VK_COLOR_SPACE_HDR10_HLG_EXT", static_cast(object)); + break; + case VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT: + dump_enum(settings, "VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT", static_cast(object)); + break; + case VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT: + dump_enum(settings, "VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT", static_cast(object)); + break; + case VK_COLOR_SPACE_PASS_THROUGH_EXT: + dump_enum(settings, "VK_COLOR_SPACE_PASS_THROUGH_EXT", static_cast(object)); + break; + case VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT: + dump_enum(settings, "VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT", static_cast(object)); + break; + case VK_COLOR_SPACE_DISPLAY_NATIVE_AMD: + dump_enum(settings, "VK_COLOR_SPACE_DISPLAY_NATIVE_AMD", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkQueryResultStatusKHR(const VkQueryResultStatusKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_QUERY_RESULT_STATUS_ERROR_KHR: + dump_enum(settings, "VK_QUERY_RESULT_STATUS_ERROR_KHR", static_cast(object)); + break; + case VK_QUERY_RESULT_STATUS_NOT_READY_KHR: + dump_enum(settings, "VK_QUERY_RESULT_STATUS_NOT_READY_KHR", static_cast(object)); + break; + case VK_QUERY_RESULT_STATUS_COMPLETE_KHR: + dump_enum(settings, "VK_QUERY_RESULT_STATUS_COMPLETE_KHR", static_cast(object)); + break; + case VK_QUERY_RESULT_STATUS_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_KHR: + dump_enum(settings, "VK_QUERY_RESULT_STATUS_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_KHR", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkPerformanceCounterUnitKHR(const VkPerformanceCounterUnitKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR: + dump_enum(settings, "VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR", static_cast(object)); + break; + case VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR: + dump_enum(settings, "VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR", static_cast(object)); + break; + case VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR: + dump_enum(settings, "VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR", static_cast(object)); + break; + case VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR: + dump_enum(settings, "VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR", static_cast(object)); + break; + case VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR: + dump_enum(settings, "VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR", static_cast(object)); + break; + case VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR: + dump_enum(settings, "VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR", static_cast(object)); + break; + case VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR: + dump_enum(settings, "VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR", static_cast(object)); + break; + case VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR: + dump_enum(settings, "VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR", static_cast(object)); + break; + case VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR: + dump_enum(settings, "VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR", static_cast(object)); + break; + case VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR: + dump_enum(settings, "VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR", static_cast(object)); + break; + case VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR: + dump_enum(settings, "VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkPerformanceCounterScopeKHR(const VkPerformanceCounterScopeKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR: + dump_enum(settings, "VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR", static_cast(object)); + break; + case VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR: + dump_enum(settings, "VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR", static_cast(object)); + break; + case VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR: + dump_enum(settings, "VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkPerformanceCounterStorageKHR(const VkPerformanceCounterStorageKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR: + dump_enum(settings, "VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR", static_cast(object)); + break; + case VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR: + dump_enum(settings, "VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR", static_cast(object)); + break; + case VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR: + dump_enum(settings, "VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR", static_cast(object)); + break; + case VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR: + dump_enum(settings, "VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR", static_cast(object)); + break; + case VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR: + dump_enum(settings, "VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR", static_cast(object)); + break; + case VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR: + dump_enum(settings, "VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkFragmentShadingRateCombinerOpKHR(const VkFragmentShadingRateCombinerOpKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR: + dump_enum(settings, "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR", static_cast(object)); + break; + case VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR: + dump_enum(settings, "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR", static_cast(object)); + break; + case VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR: + dump_enum(settings, "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR", static_cast(object)); + break; + case VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR: + dump_enum(settings, "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR", static_cast(object)); + break; + case VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR: + dump_enum(settings, "VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkPipelineExecutableStatisticFormatKHR(const VkPipelineExecutableStatisticFormatKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR: + dump_enum(settings, "VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR", static_cast(object)); + break; + case VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR: + dump_enum(settings, "VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR", static_cast(object)); + break; + case VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR: + dump_enum(settings, "VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR", static_cast(object)); + break; + case VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR: + dump_enum(settings, "VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkVideoEncodeTuningModeKHR(const VkVideoEncodeTuningModeKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_VIDEO_ENCODE_TUNING_MODE_DEFAULT_KHR: + dump_enum(settings, "VK_VIDEO_ENCODE_TUNING_MODE_DEFAULT_KHR", static_cast(object)); + break; + case VK_VIDEO_ENCODE_TUNING_MODE_HIGH_QUALITY_KHR: + dump_enum(settings, "VK_VIDEO_ENCODE_TUNING_MODE_HIGH_QUALITY_KHR", static_cast(object)); + break; + case VK_VIDEO_ENCODE_TUNING_MODE_LOW_LATENCY_KHR: + dump_enum(settings, "VK_VIDEO_ENCODE_TUNING_MODE_LOW_LATENCY_KHR", static_cast(object)); + break; + case VK_VIDEO_ENCODE_TUNING_MODE_ULTRA_LOW_LATENCY_KHR: + dump_enum(settings, "VK_VIDEO_ENCODE_TUNING_MODE_ULTRA_LOW_LATENCY_KHR", static_cast(object)); + break; + case VK_VIDEO_ENCODE_TUNING_MODE_LOSSLESS_KHR: + dump_enum(settings, "VK_VIDEO_ENCODE_TUNING_MODE_LOSSLESS_KHR", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkComponentTypeKHR(const VkComponentTypeKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_COMPONENT_TYPE_FLOAT16_KHR: + dump_enum(settings, "VK_COMPONENT_TYPE_FLOAT16_KHR", static_cast(object)); + break; + case VK_COMPONENT_TYPE_FLOAT32_KHR: + dump_enum(settings, "VK_COMPONENT_TYPE_FLOAT32_KHR", static_cast(object)); + break; + case VK_COMPONENT_TYPE_FLOAT64_KHR: + dump_enum(settings, "VK_COMPONENT_TYPE_FLOAT64_KHR", static_cast(object)); + break; + case VK_COMPONENT_TYPE_SINT8_KHR: + dump_enum(settings, "VK_COMPONENT_TYPE_SINT8_KHR", static_cast(object)); + break; + case VK_COMPONENT_TYPE_SINT16_KHR: + dump_enum(settings, "VK_COMPONENT_TYPE_SINT16_KHR", static_cast(object)); + break; + case VK_COMPONENT_TYPE_SINT32_KHR: + dump_enum(settings, "VK_COMPONENT_TYPE_SINT32_KHR", static_cast(object)); + break; + case VK_COMPONENT_TYPE_SINT64_KHR: + dump_enum(settings, "VK_COMPONENT_TYPE_SINT64_KHR", static_cast(object)); + break; + case VK_COMPONENT_TYPE_UINT8_KHR: + dump_enum(settings, "VK_COMPONENT_TYPE_UINT8_KHR", static_cast(object)); + break; + case VK_COMPONENT_TYPE_UINT16_KHR: + dump_enum(settings, "VK_COMPONENT_TYPE_UINT16_KHR", static_cast(object)); + break; + case VK_COMPONENT_TYPE_UINT32_KHR: + dump_enum(settings, "VK_COMPONENT_TYPE_UINT32_KHR", static_cast(object)); + break; + case VK_COMPONENT_TYPE_UINT64_KHR: + dump_enum(settings, "VK_COMPONENT_TYPE_UINT64_KHR", static_cast(object)); + break; + case VK_COMPONENT_TYPE_BFLOAT16_KHR: + dump_enum(settings, "VK_COMPONENT_TYPE_BFLOAT16_KHR", static_cast(object)); + break; + case VK_COMPONENT_TYPE_SINT8_PACKED_NV: + dump_enum(settings, "VK_COMPONENT_TYPE_SINT8_PACKED_NV", static_cast(object)); + break; + case VK_COMPONENT_TYPE_UINT8_PACKED_NV: + dump_enum(settings, "VK_COMPONENT_TYPE_UINT8_PACKED_NV", static_cast(object)); + break; + case VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT: + dump_enum(settings, "VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT", static_cast(object)); + break; + case VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT: + dump_enum(settings, "VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkScopeKHR(const VkScopeKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_SCOPE_DEVICE_KHR: + dump_enum(settings, "VK_SCOPE_DEVICE_KHR", static_cast(object)); + break; + case VK_SCOPE_WORKGROUP_KHR: + dump_enum(settings, "VK_SCOPE_WORKGROUP_KHR", static_cast(object)); + break; + case VK_SCOPE_SUBGROUP_KHR: + dump_enum(settings, "VK_SCOPE_SUBGROUP_KHR", static_cast(object)); + break; + case VK_SCOPE_QUEUE_FAMILY_KHR: + dump_enum(settings, "VK_SCOPE_QUEUE_FAMILY_KHR", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkVideoEncodeAV1PredictionModeKHR(const VkVideoEncodeAV1PredictionModeKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_INTRA_ONLY_KHR: + dump_enum(settings, "VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_INTRA_ONLY_KHR", static_cast(object)); + break; + case VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_SINGLE_REFERENCE_KHR: + dump_enum(settings, "VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_SINGLE_REFERENCE_KHR", static_cast(object)); + break; + case VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_UNIDIRECTIONAL_COMPOUND_KHR: + dump_enum(settings, "VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_UNIDIRECTIONAL_COMPOUND_KHR", static_cast(object)); + break; + case VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_BIDIRECTIONAL_COMPOUND_KHR: + dump_enum(settings, "VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_BIDIRECTIONAL_COMPOUND_KHR", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkVideoEncodeAV1RateControlGroupKHR(const VkVideoEncodeAV1RateControlGroupKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_INTRA_KHR: + dump_enum(settings, "VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_INTRA_KHR", static_cast(object)); + break; + case VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_PREDICTIVE_KHR: + dump_enum(settings, "VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_PREDICTIVE_KHR", static_cast(object)); + break; + case VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_BIPREDICTIVE_KHR: + dump_enum(settings, "VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_BIPREDICTIVE_KHR", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkTimeDomainKHR(const VkTimeDomainKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_TIME_DOMAIN_DEVICE_KHR: + dump_enum(settings, "VK_TIME_DOMAIN_DEVICE_KHR", static_cast(object)); + break; + case VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR: + dump_enum(settings, "VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR", static_cast(object)); + break; + case VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR: + dump_enum(settings, "VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR", static_cast(object)); + break; + case VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR: + dump_enum(settings, "VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR", static_cast(object)); + break; + case VK_TIME_DOMAIN_PRESENT_STAGE_LOCAL_EXT: + dump_enum(settings, "VK_TIME_DOMAIN_PRESENT_STAGE_LOCAL_EXT", static_cast(object)); + break; + case VK_TIME_DOMAIN_SWAPCHAIN_LOCAL_EXT: + dump_enum(settings, "VK_TIME_DOMAIN_SWAPCHAIN_LOCAL_EXT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkPhysicalDeviceLayeredApiKHR(const VkPhysicalDeviceLayeredApiKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_PHYSICAL_DEVICE_LAYERED_API_VULKAN_KHR: + dump_enum(settings, "VK_PHYSICAL_DEVICE_LAYERED_API_VULKAN_KHR", static_cast(object)); + break; + case VK_PHYSICAL_DEVICE_LAYERED_API_D3D12_KHR: + dump_enum(settings, "VK_PHYSICAL_DEVICE_LAYERED_API_D3D12_KHR", static_cast(object)); + break; + case VK_PHYSICAL_DEVICE_LAYERED_API_METAL_KHR: + dump_enum(settings, "VK_PHYSICAL_DEVICE_LAYERED_API_METAL_KHR", static_cast(object)); + break; + case VK_PHYSICAL_DEVICE_LAYERED_API_OPENGL_KHR: + dump_enum(settings, "VK_PHYSICAL_DEVICE_LAYERED_API_OPENGL_KHR", static_cast(object)); + break; + case VK_PHYSICAL_DEVICE_LAYERED_API_OPENGLES_KHR: + dump_enum(settings, "VK_PHYSICAL_DEVICE_LAYERED_API_OPENGLES_KHR", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkDefaultVertexAttributeValueKHR(const VkDefaultVertexAttributeValueKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ZERO_KHR: + dump_enum(settings, "VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ZERO_KHR", static_cast(object)); + break; + case VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ONE_KHR: + dump_enum(settings, "VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ONE_KHR", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkDebugReportObjectTypeEXT(const VkDebugReportObjectTypeEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT: + dump_enum(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT", static_cast(object)); + break; + case VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT: + dump_enum(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT", static_cast(object)); + break; + case VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT: + dump_enum(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT", static_cast(object)); + break; + case VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT: + dump_enum(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT", static_cast(object)); + break; + case VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT: + dump_enum(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT", static_cast(object)); + break; + case VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT: + dump_enum(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT", static_cast(object)); + break; + case VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT: + dump_enum(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT", static_cast(object)); + break; + case VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT: + dump_enum(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT", static_cast(object)); + break; + case VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT: + dump_enum(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT", static_cast(object)); + break; + case VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT: + dump_enum(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT", static_cast(object)); + break; + case VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT: + dump_enum(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT", static_cast(object)); + break; + case VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT: + dump_enum(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT", static_cast(object)); + break; + case VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT: + dump_enum(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT", static_cast(object)); + break; + case VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT: + dump_enum(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT", static_cast(object)); + break; + case VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT: + dump_enum(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT", static_cast(object)); + break; + case VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT: + dump_enum(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT", static_cast(object)); + break; + case VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT: + dump_enum(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT", static_cast(object)); + break; + case VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT: + dump_enum(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT", static_cast(object)); + break; + case VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT: + dump_enum(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT", static_cast(object)); + break; + case VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT: + dump_enum(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT", static_cast(object)); + break; + case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT: + dump_enum(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT", static_cast(object)); + break; + case VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT: + dump_enum(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT", static_cast(object)); + break; + case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT: + dump_enum(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT", static_cast(object)); + break; + case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT: + dump_enum(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT", static_cast(object)); + break; + case VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT: + dump_enum(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT", static_cast(object)); + break; + case VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT: + dump_enum(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT", static_cast(object)); + break; + case VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT: + dump_enum(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT", static_cast(object)); + break; + case VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT: + dump_enum(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT", static_cast(object)); + break; + case VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT: + dump_enum(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT", static_cast(object)); + break; + case VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT: + dump_enum(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT", static_cast(object)); + break; + case VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT: + dump_enum(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT", static_cast(object)); + break; + case VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT: + dump_enum(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT", static_cast(object)); + break; + case VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT: + dump_enum(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT", static_cast(object)); + break; + case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT: + dump_enum(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT", static_cast(object)); + break; + case VK_DEBUG_REPORT_OBJECT_TYPE_CU_MODULE_NVX_EXT: + dump_enum(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_CU_MODULE_NVX_EXT", static_cast(object)); + break; + case VK_DEBUG_REPORT_OBJECT_TYPE_CU_FUNCTION_NVX_EXT: + dump_enum(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_CU_FUNCTION_NVX_EXT", static_cast(object)); + break; + case VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT: + dump_enum(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT", static_cast(object)); + break; + case VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT: + dump_enum(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT", static_cast(object)); + break; + case VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_MODULE_NV_EXT: + dump_enum(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_MODULE_NV_EXT", static_cast(object)); + break; + case VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_FUNCTION_NV_EXT: + dump_enum(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_FUNCTION_NV_EXT", static_cast(object)); + break; + case VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA_EXT: + dump_enum(settings, "VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA_EXT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkRasterizationOrderAMD(const VkRasterizationOrderAMD object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_RASTERIZATION_ORDER_STRICT_AMD: + dump_enum(settings, "VK_RASTERIZATION_ORDER_STRICT_AMD", static_cast(object)); + break; + case VK_RASTERIZATION_ORDER_RELAXED_AMD: + dump_enum(settings, "VK_RASTERIZATION_ORDER_RELAXED_AMD", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkShaderInfoTypeAMD(const VkShaderInfoTypeAMD object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_SHADER_INFO_TYPE_STATISTICS_AMD: + dump_enum(settings, "VK_SHADER_INFO_TYPE_STATISTICS_AMD", static_cast(object)); + break; + case VK_SHADER_INFO_TYPE_BINARY_AMD: + dump_enum(settings, "VK_SHADER_INFO_TYPE_BINARY_AMD", static_cast(object)); + break; + case VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD: + dump_enum(settings, "VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkValidationCheckEXT(const VkValidationCheckEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_VALIDATION_CHECK_ALL_EXT: + dump_enum(settings, "VK_VALIDATION_CHECK_ALL_EXT", static_cast(object)); + break; + case VK_VALIDATION_CHECK_SHADERS_EXT: + dump_enum(settings, "VK_VALIDATION_CHECK_SHADERS_EXT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkDisplayPowerStateEXT(const VkDisplayPowerStateEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_DISPLAY_POWER_STATE_OFF_EXT: + dump_enum(settings, "VK_DISPLAY_POWER_STATE_OFF_EXT", static_cast(object)); + break; + case VK_DISPLAY_POWER_STATE_SUSPEND_EXT: + dump_enum(settings, "VK_DISPLAY_POWER_STATE_SUSPEND_EXT", static_cast(object)); + break; + case VK_DISPLAY_POWER_STATE_ON_EXT: + dump_enum(settings, "VK_DISPLAY_POWER_STATE_ON_EXT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkDeviceEventTypeEXT(const VkDeviceEventTypeEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT: + dump_enum(settings, "VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkDisplayEventTypeEXT(const VkDisplayEventTypeEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT: + dump_enum(settings, "VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkViewportCoordinateSwizzleNV(const VkViewportCoordinateSwizzleNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV: + dump_enum(settings, "VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV", static_cast(object)); + break; + case VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV: + dump_enum(settings, "VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV", static_cast(object)); + break; + case VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV: + dump_enum(settings, "VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV", static_cast(object)); + break; + case VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV: + dump_enum(settings, "VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV", static_cast(object)); + break; + case VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV: + dump_enum(settings, "VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV", static_cast(object)); + break; + case VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV: + dump_enum(settings, "VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV", static_cast(object)); + break; + case VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV: + dump_enum(settings, "VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV", static_cast(object)); + break; + case VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV: + dump_enum(settings, "VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkDiscardRectangleModeEXT(const VkDiscardRectangleModeEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT: + dump_enum(settings, "VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT", static_cast(object)); + break; + case VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT: + dump_enum(settings, "VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkConservativeRasterizationModeEXT(const VkConservativeRasterizationModeEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT: + dump_enum(settings, "VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT", static_cast(object)); + break; + case VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT: + dump_enum(settings, "VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT", static_cast(object)); + break; + case VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT: + dump_enum(settings, "VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkDescriptorMappingSourceEXT(const VkDescriptorMappingSourceEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_CONSTANT_OFFSET_EXT: + dump_enum(settings, "VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_CONSTANT_OFFSET_EXT", static_cast(object)); + break; + case VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_PUSH_INDEX_EXT: + dump_enum(settings, "VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_PUSH_INDEX_EXT", static_cast(object)); + break; + case VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_INDIRECT_INDEX_EXT: + dump_enum(settings, "VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_INDIRECT_INDEX_EXT", static_cast(object)); + break; + case VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_INDIRECT_INDEX_ARRAY_EXT: + dump_enum(settings, "VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_INDIRECT_INDEX_ARRAY_EXT", static_cast(object)); + break; + case VK_DESCRIPTOR_MAPPING_SOURCE_RESOURCE_HEAP_DATA_EXT: + dump_enum(settings, "VK_DESCRIPTOR_MAPPING_SOURCE_RESOURCE_HEAP_DATA_EXT", static_cast(object)); + break; + case VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_DATA_EXT: + dump_enum(settings, "VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_DATA_EXT", static_cast(object)); + break; + case VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_ADDRESS_EXT: + dump_enum(settings, "VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_ADDRESS_EXT", static_cast(object)); + break; + case VK_DESCRIPTOR_MAPPING_SOURCE_INDIRECT_ADDRESS_EXT: + dump_enum(settings, "VK_DESCRIPTOR_MAPPING_SOURCE_INDIRECT_ADDRESS_EXT", static_cast(object)); + break; + case VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_SHADER_RECORD_INDEX_EXT: + dump_enum(settings, "VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_SHADER_RECORD_INDEX_EXT", static_cast(object)); + break; + case VK_DESCRIPTOR_MAPPING_SOURCE_SHADER_RECORD_DATA_EXT: + dump_enum(settings, "VK_DESCRIPTOR_MAPPING_SOURCE_SHADER_RECORD_DATA_EXT", static_cast(object)); + break; + case VK_DESCRIPTOR_MAPPING_SOURCE_SHADER_RECORD_ADDRESS_EXT: + dump_enum(settings, "VK_DESCRIPTOR_MAPPING_SOURCE_SHADER_RECORD_ADDRESS_EXT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkBlendOverlapEXT(const VkBlendOverlapEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_BLEND_OVERLAP_UNCORRELATED_EXT: + dump_enum(settings, "VK_BLEND_OVERLAP_UNCORRELATED_EXT", static_cast(object)); + break; + case VK_BLEND_OVERLAP_DISJOINT_EXT: + dump_enum(settings, "VK_BLEND_OVERLAP_DISJOINT_EXT", static_cast(object)); + break; + case VK_BLEND_OVERLAP_CONJOINT_EXT: + dump_enum(settings, "VK_BLEND_OVERLAP_CONJOINT_EXT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkCoverageModulationModeNV(const VkCoverageModulationModeNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_COVERAGE_MODULATION_MODE_NONE_NV: + dump_enum(settings, "VK_COVERAGE_MODULATION_MODE_NONE_NV", static_cast(object)); + break; + case VK_COVERAGE_MODULATION_MODE_RGB_NV: + dump_enum(settings, "VK_COVERAGE_MODULATION_MODE_RGB_NV", static_cast(object)); + break; + case VK_COVERAGE_MODULATION_MODE_ALPHA_NV: + dump_enum(settings, "VK_COVERAGE_MODULATION_MODE_ALPHA_NV", static_cast(object)); + break; + case VK_COVERAGE_MODULATION_MODE_RGBA_NV: + dump_enum(settings, "VK_COVERAGE_MODULATION_MODE_RGBA_NV", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkValidationCacheHeaderVersionEXT(const VkValidationCacheHeaderVersionEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT: + dump_enum(settings, "VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkShadingRatePaletteEntryNV(const VkShadingRatePaletteEntryNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV: + dump_enum(settings, "VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV", static_cast(object)); + break; + case VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV: + dump_enum(settings, "VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV", static_cast(object)); + break; + case VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV: + dump_enum(settings, "VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV", static_cast(object)); + break; + case VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV: + dump_enum(settings, "VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV", static_cast(object)); + break; + case VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV: + dump_enum(settings, "VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV", static_cast(object)); + break; + case VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV: + dump_enum(settings, "VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV", static_cast(object)); + break; + case VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV: + dump_enum(settings, "VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV", static_cast(object)); + break; + case VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV: + dump_enum(settings, "VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV", static_cast(object)); + break; + case VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV: + dump_enum(settings, "VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV", static_cast(object)); + break; + case VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV: + dump_enum(settings, "VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV", static_cast(object)); + break; + case VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV: + dump_enum(settings, "VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV", static_cast(object)); + break; + case VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV: + dump_enum(settings, "VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkCoarseSampleOrderTypeNV(const VkCoarseSampleOrderTypeNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV: + dump_enum(settings, "VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV", static_cast(object)); + break; + case VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV: + dump_enum(settings, "VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV", static_cast(object)); + break; + case VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV: + dump_enum(settings, "VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV", static_cast(object)); + break; + case VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV: + dump_enum(settings, "VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkRayTracingShaderGroupTypeKHR(const VkRayTracingShaderGroupTypeKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR: + dump_enum(settings, "VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR", static_cast(object)); + break; + case VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR: + dump_enum(settings, "VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR", static_cast(object)); + break; + case VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR: + dump_enum(settings, "VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkGeometryTypeKHR(const VkGeometryTypeKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_GEOMETRY_TYPE_TRIANGLES_KHR: + dump_enum(settings, "VK_GEOMETRY_TYPE_TRIANGLES_KHR", static_cast(object)); + break; + case VK_GEOMETRY_TYPE_AABBS_KHR: + dump_enum(settings, "VK_GEOMETRY_TYPE_AABBS_KHR", static_cast(object)); + break; + case VK_GEOMETRY_TYPE_INSTANCES_KHR: + dump_enum(settings, "VK_GEOMETRY_TYPE_INSTANCES_KHR", static_cast(object)); + break; + case VK_GEOMETRY_TYPE_SPHERES_NV: + dump_enum(settings, "VK_GEOMETRY_TYPE_SPHERES_NV", static_cast(object)); + break; + case VK_GEOMETRY_TYPE_LINEAR_SWEPT_SPHERES_NV: + dump_enum(settings, "VK_GEOMETRY_TYPE_LINEAR_SWEPT_SPHERES_NV", static_cast(object)); + break; +#if defined(VK_ENABLE_BETA_EXTENSIONS) + case VK_GEOMETRY_TYPE_DENSE_GEOMETRY_FORMAT_TRIANGLES_AMDX: + dump_enum(settings, "VK_GEOMETRY_TYPE_DENSE_GEOMETRY_FORMAT_TRIANGLES_AMDX", static_cast(object)); + break; +#endif // VK_ENABLE_BETA_EXTENSIONS + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkAccelerationStructureTypeKHR(const VkAccelerationStructureTypeKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR: + dump_enum(settings, "VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR", static_cast(object)); + break; + case VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR: + dump_enum(settings, "VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR", static_cast(object)); + break; + case VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR: + dump_enum(settings, "VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkCopyAccelerationStructureModeKHR(const VkCopyAccelerationStructureModeKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR: + dump_enum(settings, "VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR", static_cast(object)); + break; + case VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR: + dump_enum(settings, "VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR", static_cast(object)); + break; + case VK_COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR: + dump_enum(settings, "VK_COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR", static_cast(object)); + break; + case VK_COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR: + dump_enum(settings, "VK_COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkAccelerationStructureMemoryRequirementsTypeNV(const VkAccelerationStructureMemoryRequirementsTypeNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV: + dump_enum(settings, "VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV", static_cast(object)); + break; + case VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV: + dump_enum(settings, "VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV", static_cast(object)); + break; + case VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV: + dump_enum(settings, "VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkMemoryOverallocationBehaviorAMD(const VkMemoryOverallocationBehaviorAMD object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD: + dump_enum(settings, "VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD", static_cast(object)); + break; + case VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD: + dump_enum(settings, "VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD", static_cast(object)); + break; + case VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD: + dump_enum(settings, "VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkPerformanceConfigurationTypeINTEL(const VkPerformanceConfigurationTypeINTEL object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL: + dump_enum(settings, "VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkQueryPoolSamplingModeINTEL(const VkQueryPoolSamplingModeINTEL object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL: + dump_enum(settings, "VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkPerformanceOverrideTypeINTEL(const VkPerformanceOverrideTypeINTEL object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL: + dump_enum(settings, "VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL", static_cast(object)); + break; + case VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL: + dump_enum(settings, "VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkPerformanceParameterTypeINTEL(const VkPerformanceParameterTypeINTEL object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL: + dump_enum(settings, "VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL", static_cast(object)); + break; + case VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL: + dump_enum(settings, "VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkPerformanceValueTypeINTEL(const VkPerformanceValueTypeINTEL object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL: + dump_enum(settings, "VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL", static_cast(object)); + break; + case VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL: + dump_enum(settings, "VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL", static_cast(object)); + break; + case VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL: + dump_enum(settings, "VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL", static_cast(object)); + break; + case VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL: + dump_enum(settings, "VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL", static_cast(object)); + break; + case VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL: + dump_enum(settings, "VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkValidationFeatureEnableEXT(const VkValidationFeatureEnableEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT: + dump_enum(settings, "VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT", static_cast(object)); + break; + case VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT: + dump_enum(settings, "VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT", static_cast(object)); + break; + case VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT: + dump_enum(settings, "VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT", static_cast(object)); + break; + case VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT: + dump_enum(settings, "VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT", static_cast(object)); + break; + case VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT: + dump_enum(settings, "VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkValidationFeatureDisableEXT(const VkValidationFeatureDisableEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_VALIDATION_FEATURE_DISABLE_ALL_EXT: + dump_enum(settings, "VK_VALIDATION_FEATURE_DISABLE_ALL_EXT", static_cast(object)); + break; + case VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT: + dump_enum(settings, "VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT", static_cast(object)); + break; + case VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT: + dump_enum(settings, "VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT", static_cast(object)); + break; + case VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT: + dump_enum(settings, "VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT", static_cast(object)); + break; + case VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT: + dump_enum(settings, "VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT", static_cast(object)); + break; + case VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT: + dump_enum(settings, "VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT", static_cast(object)); + break; + case VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT: + dump_enum(settings, "VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT", static_cast(object)); + break; + case VK_VALIDATION_FEATURE_DISABLE_SHADER_VALIDATION_CACHE_EXT: + dump_enum(settings, "VK_VALIDATION_FEATURE_DISABLE_SHADER_VALIDATION_CACHE_EXT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkCoverageReductionModeNV(const VkCoverageReductionModeNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_COVERAGE_REDUCTION_MODE_MERGE_NV: + dump_enum(settings, "VK_COVERAGE_REDUCTION_MODE_MERGE_NV", static_cast(object)); + break; + case VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV: + dump_enum(settings, "VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkProvokingVertexModeEXT(const VkProvokingVertexModeEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT: + dump_enum(settings, "VK_PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT", static_cast(object)); + break; + case VK_PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT: + dump_enum(settings, "VK_PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +#if defined(VK_USE_PLATFORM_WIN32_KHR) +template +void dump_VkFullScreenExclusiveEXT(const VkFullScreenExclusiveEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT: + dump_enum(settings, "VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT", static_cast(object)); + break; + case VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT: + dump_enum(settings, "VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT", static_cast(object)); + break; + case VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT: + dump_enum(settings, "VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT", static_cast(object)); + break; + case VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT: + dump_enum(settings, "VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +#endif // VK_USE_PLATFORM_WIN32_KHR +template +void dump_VkIndirectCommandsTokenTypeNV(const VkIndirectCommandsTokenTypeNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV: + dump_enum(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV", static_cast(object)); + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV: + dump_enum(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV", static_cast(object)); + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NV: + dump_enum(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NV", static_cast(object)); + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV: + dump_enum(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV", static_cast(object)); + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV: + dump_enum(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV", static_cast(object)); + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV: + dump_enum(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV", static_cast(object)); + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV: + dump_enum(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV", static_cast(object)); + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV: + dump_enum(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV", static_cast(object)); + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_DATA_NV: + dump_enum(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_DATA_NV", static_cast(object)); + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV: + dump_enum(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV", static_cast(object)); + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NV: + dump_enum(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NV", static_cast(object)); + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NV: + dump_enum(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NV", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkDepthBiasRepresentationEXT(const VkDepthBiasRepresentationEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORMAT_EXT: + dump_enum(settings, "VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORMAT_EXT", static_cast(object)); + break; + case VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORCE_UNORM_EXT: + dump_enum(settings, "VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORCE_UNORM_EXT", static_cast(object)); + break; + case VK_DEPTH_BIAS_REPRESENTATION_FLOAT_EXT: + dump_enum(settings, "VK_DEPTH_BIAS_REPRESENTATION_FLOAT_EXT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkDeviceMemoryReportEventTypeEXT(const VkDeviceMemoryReportEventTypeEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT: + dump_enum(settings, "VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT", static_cast(object)); + break; + case VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT: + dump_enum(settings, "VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT", static_cast(object)); + break; + case VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT: + dump_enum(settings, "VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT", static_cast(object)); + break; + case VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT: + dump_enum(settings, "VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT", static_cast(object)); + break; + case VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT: + dump_enum(settings, "VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkFragmentShadingRateTypeNV(const VkFragmentShadingRateTypeNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_FRAGMENT_SHADING_RATE_TYPE_FRAGMENT_SIZE_NV: + dump_enum(settings, "VK_FRAGMENT_SHADING_RATE_TYPE_FRAGMENT_SIZE_NV", static_cast(object)); + break; + case VK_FRAGMENT_SHADING_RATE_TYPE_ENUMS_NV: + dump_enum(settings, "VK_FRAGMENT_SHADING_RATE_TYPE_ENUMS_NV", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkFragmentShadingRateNV(const VkFragmentShadingRateNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV: + dump_enum(settings, "VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV", static_cast(object)); + break; + case VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV: + dump_enum(settings, "VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV", static_cast(object)); + break; + case VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV: + dump_enum(settings, "VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV", static_cast(object)); + break; + case VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV: + dump_enum(settings, "VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV", static_cast(object)); + break; + case VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV: + dump_enum(settings, "VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV", static_cast(object)); + break; + case VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV: + dump_enum(settings, "VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV", static_cast(object)); + break; + case VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV: + dump_enum(settings, "VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV", static_cast(object)); + break; + case VK_FRAGMENT_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV: + dump_enum(settings, "VK_FRAGMENT_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV", static_cast(object)); + break; + case VK_FRAGMENT_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV: + dump_enum(settings, "VK_FRAGMENT_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV", static_cast(object)); + break; + case VK_FRAGMENT_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV: + dump_enum(settings, "VK_FRAGMENT_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV", static_cast(object)); + break; + case VK_FRAGMENT_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV: + dump_enum(settings, "VK_FRAGMENT_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV", static_cast(object)); + break; + case VK_FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV: + dump_enum(settings, "VK_FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkAccelerationStructureMotionInstanceTypeNV(const VkAccelerationStructureMotionInstanceTypeNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_STATIC_NV: + dump_enum(settings, "VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_STATIC_NV", static_cast(object)); + break; + case VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MATRIX_MOTION_NV: + dump_enum(settings, "VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MATRIX_MOTION_NV", static_cast(object)); + break; + case VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_SRT_MOTION_NV: + dump_enum(settings, "VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_SRT_MOTION_NV", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkDeviceFaultAddressTypeEXT(const VkDeviceFaultAddressTypeEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_DEVICE_FAULT_ADDRESS_TYPE_NONE_EXT: + dump_enum(settings, "VK_DEVICE_FAULT_ADDRESS_TYPE_NONE_EXT", static_cast(object)); + break; + case VK_DEVICE_FAULT_ADDRESS_TYPE_READ_INVALID_EXT: + dump_enum(settings, "VK_DEVICE_FAULT_ADDRESS_TYPE_READ_INVALID_EXT", static_cast(object)); + break; + case VK_DEVICE_FAULT_ADDRESS_TYPE_WRITE_INVALID_EXT: + dump_enum(settings, "VK_DEVICE_FAULT_ADDRESS_TYPE_WRITE_INVALID_EXT", static_cast(object)); + break; + case VK_DEVICE_FAULT_ADDRESS_TYPE_EXECUTE_INVALID_EXT: + dump_enum(settings, "VK_DEVICE_FAULT_ADDRESS_TYPE_EXECUTE_INVALID_EXT", static_cast(object)); + break; + case VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_UNKNOWN_EXT: + dump_enum(settings, "VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_UNKNOWN_EXT", static_cast(object)); + break; + case VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_INVALID_EXT: + dump_enum(settings, "VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_INVALID_EXT", static_cast(object)); + break; + case VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_FAULT_EXT: + dump_enum(settings, "VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_FAULT_EXT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkDeviceFaultVendorBinaryHeaderVersionEXT(const VkDeviceFaultVendorBinaryHeaderVersionEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_ONE_EXT: + dump_enum(settings, "VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_ONE_EXT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkDeviceAddressBindingTypeEXT(const VkDeviceAddressBindingTypeEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_DEVICE_ADDRESS_BINDING_TYPE_BIND_EXT: + dump_enum(settings, "VK_DEVICE_ADDRESS_BINDING_TYPE_BIND_EXT", static_cast(object)); + break; + case VK_DEVICE_ADDRESS_BINDING_TYPE_UNBIND_EXT: + dump_enum(settings, "VK_DEVICE_ADDRESS_BINDING_TYPE_UNBIND_EXT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkMicromapTypeEXT(const VkMicromapTypeEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_MICROMAP_TYPE_OPACITY_MICROMAP_EXT: + dump_enum(settings, "VK_MICROMAP_TYPE_OPACITY_MICROMAP_EXT", static_cast(object)); + break; +#if defined(VK_ENABLE_BETA_EXTENSIONS) + case VK_MICROMAP_TYPE_DISPLACEMENT_MICROMAP_NV: + dump_enum(settings, "VK_MICROMAP_TYPE_DISPLACEMENT_MICROMAP_NV", static_cast(object)); + break; +#endif // VK_ENABLE_BETA_EXTENSIONS + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkBuildMicromapModeEXT(const VkBuildMicromapModeEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_BUILD_MICROMAP_MODE_BUILD_EXT: + dump_enum(settings, "VK_BUILD_MICROMAP_MODE_BUILD_EXT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkCopyMicromapModeEXT(const VkCopyMicromapModeEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_COPY_MICROMAP_MODE_CLONE_EXT: + dump_enum(settings, "VK_COPY_MICROMAP_MODE_CLONE_EXT", static_cast(object)); + break; + case VK_COPY_MICROMAP_MODE_SERIALIZE_EXT: + dump_enum(settings, "VK_COPY_MICROMAP_MODE_SERIALIZE_EXT", static_cast(object)); + break; + case VK_COPY_MICROMAP_MODE_DESERIALIZE_EXT: + dump_enum(settings, "VK_COPY_MICROMAP_MODE_DESERIALIZE_EXT", static_cast(object)); + break; + case VK_COPY_MICROMAP_MODE_COMPACT_EXT: + dump_enum(settings, "VK_COPY_MICROMAP_MODE_COMPACT_EXT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkOpacityMicromapFormatEXT(const VkOpacityMicromapFormatEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_OPACITY_MICROMAP_FORMAT_2_STATE_EXT: + dump_enum(settings, "VK_OPACITY_MICROMAP_FORMAT_2_STATE_EXT", static_cast(object)); + break; + case VK_OPACITY_MICROMAP_FORMAT_4_STATE_EXT: + dump_enum(settings, "VK_OPACITY_MICROMAP_FORMAT_4_STATE_EXT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkOpacityMicromapSpecialIndexEXT(const VkOpacityMicromapSpecialIndexEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_EXT: + dump_enum(settings, "VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_EXT", static_cast(object)); + break; + case VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_EXT: + dump_enum(settings, "VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_EXT", static_cast(object)); + break; + case VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_EXT: + dump_enum(settings, "VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_EXT", static_cast(object)); + break; + case VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_EXT: + dump_enum(settings, "VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_EXT", static_cast(object)); + break; + case VK_OPACITY_MICROMAP_SPECIAL_INDEX_CLUSTER_GEOMETRY_DISABLE_OPACITY_MICROMAP_NV: + dump_enum(settings, "VK_OPACITY_MICROMAP_SPECIAL_INDEX_CLUSTER_GEOMETRY_DISABLE_OPACITY_MICROMAP_NV", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkAccelerationStructureCompatibilityKHR(const VkAccelerationStructureCompatibilityKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_ACCELERATION_STRUCTURE_COMPATIBILITY_COMPATIBLE_KHR: + dump_enum(settings, "VK_ACCELERATION_STRUCTURE_COMPATIBILITY_COMPATIBLE_KHR", static_cast(object)); + break; + case VK_ACCELERATION_STRUCTURE_COMPATIBILITY_INCOMPATIBLE_KHR: + dump_enum(settings, "VK_ACCELERATION_STRUCTURE_COMPATIBILITY_INCOMPATIBLE_KHR", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkAccelerationStructureBuildTypeKHR(const VkAccelerationStructureBuildTypeKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_KHR: + dump_enum(settings, "VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_KHR", static_cast(object)); + break; + case VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR: + dump_enum(settings, "VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR", static_cast(object)); + break; + case VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_OR_DEVICE_KHR: + dump_enum(settings, "VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_OR_DEVICE_KHR", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +#if defined(VK_ENABLE_BETA_EXTENSIONS) +template +void dump_VkDisplacementMicromapFormatNV(const VkDisplacementMicromapFormatNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_DISPLACEMENT_MICROMAP_FORMAT_64_TRIANGLES_64_BYTES_NV: + dump_enum(settings, "VK_DISPLACEMENT_MICROMAP_FORMAT_64_TRIANGLES_64_BYTES_NV", static_cast(object)); + break; + case VK_DISPLACEMENT_MICROMAP_FORMAT_256_TRIANGLES_128_BYTES_NV: + dump_enum(settings, "VK_DISPLACEMENT_MICROMAP_FORMAT_256_TRIANGLES_128_BYTES_NV", static_cast(object)); + break; + case VK_DISPLACEMENT_MICROMAP_FORMAT_1024_TRIANGLES_128_BYTES_NV: + dump_enum(settings, "VK_DISPLACEMENT_MICROMAP_FORMAT_1024_TRIANGLES_128_BYTES_NV", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +#endif // VK_ENABLE_BETA_EXTENSIONS +template +void dump_VkRayTracingLssIndexingModeNV(const VkRayTracingLssIndexingModeNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_RAY_TRACING_LSS_INDEXING_MODE_LIST_NV: + dump_enum(settings, "VK_RAY_TRACING_LSS_INDEXING_MODE_LIST_NV", static_cast(object)); + break; + case VK_RAY_TRACING_LSS_INDEXING_MODE_SUCCESSIVE_NV: + dump_enum(settings, "VK_RAY_TRACING_LSS_INDEXING_MODE_SUCCESSIVE_NV", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkRayTracingLssPrimitiveEndCapsModeNV(const VkRayTracingLssPrimitiveEndCapsModeNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_NONE_NV: + dump_enum(settings, "VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_NONE_NV", static_cast(object)); + break; + case VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_CHAINED_NV: + dump_enum(settings, "VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_CHAINED_NV", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkSubpassMergeStatusEXT(const VkSubpassMergeStatusEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_SUBPASS_MERGE_STATUS_MERGED_EXT: + dump_enum(settings, "VK_SUBPASS_MERGE_STATUS_MERGED_EXT", static_cast(object)); + break; + case VK_SUBPASS_MERGE_STATUS_DISALLOWED_EXT: + dump_enum(settings, "VK_SUBPASS_MERGE_STATUS_DISALLOWED_EXT", static_cast(object)); + break; + case VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SIDE_EFFECTS_EXT: + dump_enum(settings, "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SIDE_EFFECTS_EXT", static_cast(object)); + break; + case VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SAMPLES_MISMATCH_EXT: + dump_enum(settings, "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SAMPLES_MISMATCH_EXT", static_cast(object)); + break; + case VK_SUBPASS_MERGE_STATUS_NOT_MERGED_VIEWS_MISMATCH_EXT: + dump_enum(settings, "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_VIEWS_MISMATCH_EXT", static_cast(object)); + break; + case VK_SUBPASS_MERGE_STATUS_NOT_MERGED_ALIASING_EXT: + dump_enum(settings, "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_ALIASING_EXT", static_cast(object)); + break; + case VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPENDENCIES_EXT: + dump_enum(settings, "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPENDENCIES_EXT", static_cast(object)); + break; + case VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT_EXT: + dump_enum(settings, "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT_EXT", static_cast(object)); + break; + case VK_SUBPASS_MERGE_STATUS_NOT_MERGED_TOO_MANY_ATTACHMENTS_EXT: + dump_enum(settings, "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_TOO_MANY_ATTACHMENTS_EXT", static_cast(object)); + break; + case VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INSUFFICIENT_STORAGE_EXT: + dump_enum(settings, "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INSUFFICIENT_STORAGE_EXT", static_cast(object)); + break; + case VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPTH_STENCIL_COUNT_EXT: + dump_enum(settings, "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPTH_STENCIL_COUNT_EXT", static_cast(object)); + break; + case VK_SUBPASS_MERGE_STATUS_NOT_MERGED_RESOLVE_ATTACHMENT_REUSE_EXT: + dump_enum(settings, "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_RESOLVE_ATTACHMENT_REUSE_EXT", static_cast(object)); + break; + case VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SINGLE_SUBPASS_EXT: + dump_enum(settings, "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SINGLE_SUBPASS_EXT", static_cast(object)); + break; + case VK_SUBPASS_MERGE_STATUS_NOT_MERGED_UNSPECIFIED_EXT: + dump_enum(settings, "VK_SUBPASS_MERGE_STATUS_NOT_MERGED_UNSPECIFIED_EXT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkDirectDriverLoadingModeLUNARG(const VkDirectDriverLoadingModeLUNARG object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_DIRECT_DRIVER_LOADING_MODE_EXCLUSIVE_LUNARG: + dump_enum(settings, "VK_DIRECT_DRIVER_LOADING_MODE_EXCLUSIVE_LUNARG", static_cast(object)); + break; + case VK_DIRECT_DRIVER_LOADING_MODE_INCLUSIVE_LUNARG: + dump_enum(settings, "VK_DIRECT_DRIVER_LOADING_MODE_INCLUSIVE_LUNARG", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkTensorTilingARM(const VkTensorTilingARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_TENSOR_TILING_OPTIMAL_ARM: + dump_enum(settings, "VK_TENSOR_TILING_OPTIMAL_ARM", static_cast(object)); + break; + case VK_TENSOR_TILING_LINEAR_ARM: + dump_enum(settings, "VK_TENSOR_TILING_LINEAR_ARM", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkOpticalFlowPerformanceLevelNV(const VkOpticalFlowPerformanceLevelNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_UNKNOWN_NV: + dump_enum(settings, "VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_UNKNOWN_NV", static_cast(object)); + break; + case VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_SLOW_NV: + dump_enum(settings, "VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_SLOW_NV", static_cast(object)); + break; + case VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_MEDIUM_NV: + dump_enum(settings, "VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_MEDIUM_NV", static_cast(object)); + break; + case VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_FAST_NV: + dump_enum(settings, "VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_FAST_NV", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkOpticalFlowSessionBindingPointNV(const VkOpticalFlowSessionBindingPointNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_OPTICAL_FLOW_SESSION_BINDING_POINT_UNKNOWN_NV: + dump_enum(settings, "VK_OPTICAL_FLOW_SESSION_BINDING_POINT_UNKNOWN_NV", static_cast(object)); + break; + case VK_OPTICAL_FLOW_SESSION_BINDING_POINT_INPUT_NV: + dump_enum(settings, "VK_OPTICAL_FLOW_SESSION_BINDING_POINT_INPUT_NV", static_cast(object)); + break; + case VK_OPTICAL_FLOW_SESSION_BINDING_POINT_REFERENCE_NV: + dump_enum(settings, "VK_OPTICAL_FLOW_SESSION_BINDING_POINT_REFERENCE_NV", static_cast(object)); + break; + case VK_OPTICAL_FLOW_SESSION_BINDING_POINT_HINT_NV: + dump_enum(settings, "VK_OPTICAL_FLOW_SESSION_BINDING_POINT_HINT_NV", static_cast(object)); + break; + case VK_OPTICAL_FLOW_SESSION_BINDING_POINT_FLOW_VECTOR_NV: + dump_enum(settings, "VK_OPTICAL_FLOW_SESSION_BINDING_POINT_FLOW_VECTOR_NV", static_cast(object)); + break; + case VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_FLOW_VECTOR_NV: + dump_enum(settings, "VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_FLOW_VECTOR_NV", static_cast(object)); + break; + case VK_OPTICAL_FLOW_SESSION_BINDING_POINT_COST_NV: + dump_enum(settings, "VK_OPTICAL_FLOW_SESSION_BINDING_POINT_COST_NV", static_cast(object)); + break; + case VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_COST_NV: + dump_enum(settings, "VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_COST_NV", static_cast(object)); + break; + case VK_OPTICAL_FLOW_SESSION_BINDING_POINT_GLOBAL_FLOW_NV: + dump_enum(settings, "VK_OPTICAL_FLOW_SESSION_BINDING_POINT_GLOBAL_FLOW_NV", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkAntiLagModeAMD(const VkAntiLagModeAMD object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_ANTI_LAG_MODE_DRIVER_CONTROL_AMD: + dump_enum(settings, "VK_ANTI_LAG_MODE_DRIVER_CONTROL_AMD", static_cast(object)); + break; + case VK_ANTI_LAG_MODE_ON_AMD: + dump_enum(settings, "VK_ANTI_LAG_MODE_ON_AMD", static_cast(object)); + break; + case VK_ANTI_LAG_MODE_OFF_AMD: + dump_enum(settings, "VK_ANTI_LAG_MODE_OFF_AMD", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkAntiLagStageAMD(const VkAntiLagStageAMD object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_ANTI_LAG_STAGE_INPUT_AMD: + dump_enum(settings, "VK_ANTI_LAG_STAGE_INPUT_AMD", static_cast(object)); + break; + case VK_ANTI_LAG_STAGE_PRESENT_AMD: + dump_enum(settings, "VK_ANTI_LAG_STAGE_PRESENT_AMD", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +#if defined(VK_ENABLE_BETA_EXTENSIONS) +template +void dump_VkCompressedTriangleFormatAMDX(const VkCompressedTriangleFormatAMDX object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_AMDX: + dump_enum(settings, "VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_AMDX", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +#endif // VK_ENABLE_BETA_EXTENSIONS +template +void dump_VkShaderCodeTypeEXT(const VkShaderCodeTypeEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_SHADER_CODE_TYPE_BINARY_EXT: + dump_enum(settings, "VK_SHADER_CODE_TYPE_BINARY_EXT", static_cast(object)); + break; + case VK_SHADER_CODE_TYPE_SPIRV_EXT: + dump_enum(settings, "VK_SHADER_CODE_TYPE_SPIRV_EXT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkDepthClampModeEXT(const VkDepthClampModeEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_DEPTH_CLAMP_MODE_VIEWPORT_RANGE_EXT: + dump_enum(settings, "VK_DEPTH_CLAMP_MODE_VIEWPORT_RANGE_EXT", static_cast(object)); + break; + case VK_DEPTH_CLAMP_MODE_USER_DEFINED_RANGE_EXT: + dump_enum(settings, "VK_DEPTH_CLAMP_MODE_USER_DEFINED_RANGE_EXT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkRayTracingInvocationReorderModeEXT(const VkRayTracingInvocationReorderModeEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_EXT: + dump_enum(settings, "VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_EXT", static_cast(object)); + break; + case VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_EXT: + dump_enum(settings, "VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_EXT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkCooperativeVectorMatrixLayoutNV(const VkCooperativeVectorMatrixLayoutNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_ROW_MAJOR_NV: + dump_enum(settings, "VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_ROW_MAJOR_NV", static_cast(object)); + break; + case VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_COLUMN_MAJOR_NV: + dump_enum(settings, "VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_COLUMN_MAJOR_NV", static_cast(object)); + break; + case VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_INFERENCING_OPTIMAL_NV: + dump_enum(settings, "VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_INFERENCING_OPTIMAL_NV", static_cast(object)); + break; + case VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_TRAINING_OPTIMAL_NV: + dump_enum(settings, "VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_TRAINING_OPTIMAL_NV", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkLayerSettingTypeEXT(const VkLayerSettingTypeEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_LAYER_SETTING_TYPE_BOOL32_EXT: + dump_enum(settings, "VK_LAYER_SETTING_TYPE_BOOL32_EXT", static_cast(object)); + break; + case VK_LAYER_SETTING_TYPE_INT32_EXT: + dump_enum(settings, "VK_LAYER_SETTING_TYPE_INT32_EXT", static_cast(object)); + break; + case VK_LAYER_SETTING_TYPE_INT64_EXT: + dump_enum(settings, "VK_LAYER_SETTING_TYPE_INT64_EXT", static_cast(object)); + break; + case VK_LAYER_SETTING_TYPE_UINT32_EXT: + dump_enum(settings, "VK_LAYER_SETTING_TYPE_UINT32_EXT", static_cast(object)); + break; + case VK_LAYER_SETTING_TYPE_UINT64_EXT: + dump_enum(settings, "VK_LAYER_SETTING_TYPE_UINT64_EXT", static_cast(object)); + break; + case VK_LAYER_SETTING_TYPE_FLOAT32_EXT: + dump_enum(settings, "VK_LAYER_SETTING_TYPE_FLOAT32_EXT", static_cast(object)); + break; + case VK_LAYER_SETTING_TYPE_FLOAT64_EXT: + dump_enum(settings, "VK_LAYER_SETTING_TYPE_FLOAT64_EXT", static_cast(object)); + break; + case VK_LAYER_SETTING_TYPE_STRING_EXT: + dump_enum(settings, "VK_LAYER_SETTING_TYPE_STRING_EXT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkLatencyMarkerNV(const VkLatencyMarkerNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_LATENCY_MARKER_SIMULATION_START_NV: + dump_enum(settings, "VK_LATENCY_MARKER_SIMULATION_START_NV", static_cast(object)); + break; + case VK_LATENCY_MARKER_SIMULATION_END_NV: + dump_enum(settings, "VK_LATENCY_MARKER_SIMULATION_END_NV", static_cast(object)); + break; + case VK_LATENCY_MARKER_RENDERSUBMIT_START_NV: + dump_enum(settings, "VK_LATENCY_MARKER_RENDERSUBMIT_START_NV", static_cast(object)); + break; + case VK_LATENCY_MARKER_RENDERSUBMIT_END_NV: + dump_enum(settings, "VK_LATENCY_MARKER_RENDERSUBMIT_END_NV", static_cast(object)); + break; + case VK_LATENCY_MARKER_PRESENT_START_NV: + dump_enum(settings, "VK_LATENCY_MARKER_PRESENT_START_NV", static_cast(object)); + break; + case VK_LATENCY_MARKER_PRESENT_END_NV: + dump_enum(settings, "VK_LATENCY_MARKER_PRESENT_END_NV", static_cast(object)); + break; + case VK_LATENCY_MARKER_INPUT_SAMPLE_NV: + dump_enum(settings, "VK_LATENCY_MARKER_INPUT_SAMPLE_NV", static_cast(object)); + break; + case VK_LATENCY_MARKER_TRIGGER_FLASH_NV: + dump_enum(settings, "VK_LATENCY_MARKER_TRIGGER_FLASH_NV", static_cast(object)); + break; + case VK_LATENCY_MARKER_OUT_OF_BAND_RENDERSUBMIT_START_NV: + dump_enum(settings, "VK_LATENCY_MARKER_OUT_OF_BAND_RENDERSUBMIT_START_NV", static_cast(object)); + break; + case VK_LATENCY_MARKER_OUT_OF_BAND_RENDERSUBMIT_END_NV: + dump_enum(settings, "VK_LATENCY_MARKER_OUT_OF_BAND_RENDERSUBMIT_END_NV", static_cast(object)); + break; + case VK_LATENCY_MARKER_OUT_OF_BAND_PRESENT_START_NV: + dump_enum(settings, "VK_LATENCY_MARKER_OUT_OF_BAND_PRESENT_START_NV", static_cast(object)); + break; + case VK_LATENCY_MARKER_OUT_OF_BAND_PRESENT_END_NV: + dump_enum(settings, "VK_LATENCY_MARKER_OUT_OF_BAND_PRESENT_END_NV", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkOutOfBandQueueTypeNV(const VkOutOfBandQueueTypeNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_OUT_OF_BAND_QUEUE_TYPE_RENDER_NV: + dump_enum(settings, "VK_OUT_OF_BAND_QUEUE_TYPE_RENDER_NV", static_cast(object)); + break; + case VK_OUT_OF_BAND_QUEUE_TYPE_PRESENT_NV: + dump_enum(settings, "VK_OUT_OF_BAND_QUEUE_TYPE_PRESENT_NV", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkDataGraphPipelineSessionBindPointARM(const VkDataGraphPipelineSessionBindPointARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TRANSIENT_ARM: + dump_enum(settings, "VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TRANSIENT_ARM", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkDataGraphPipelineSessionBindPointTypeARM(const VkDataGraphPipelineSessionBindPointTypeARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TYPE_MEMORY_ARM: + dump_enum(settings, "VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TYPE_MEMORY_ARM", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkDataGraphPipelinePropertyARM(const VkDataGraphPipelinePropertyARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_DATA_GRAPH_PIPELINE_PROPERTY_CREATION_LOG_ARM: + dump_enum(settings, "VK_DATA_GRAPH_PIPELINE_PROPERTY_CREATION_LOG_ARM", static_cast(object)); + break; + case VK_DATA_GRAPH_PIPELINE_PROPERTY_IDENTIFIER_ARM: + dump_enum(settings, "VK_DATA_GRAPH_PIPELINE_PROPERTY_IDENTIFIER_ARM", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkPhysicalDeviceDataGraphProcessingEngineTypeARM(const VkPhysicalDeviceDataGraphProcessingEngineTypeARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_DEFAULT_ARM: + dump_enum(settings, "VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_DEFAULT_ARM", static_cast(object)); + break; + case VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_NEURAL_QCOM: + dump_enum(settings, "VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_NEURAL_QCOM", static_cast(object)); + break; + case VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_COMPUTE_QCOM: + dump_enum(settings, "VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_COMPUTE_QCOM", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkPhysicalDeviceDataGraphOperationTypeARM(const VkPhysicalDeviceDataGraphOperationTypeARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_SPIRV_EXTENDED_INSTRUCTION_SET_ARM: + dump_enum(settings, "VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_SPIRV_EXTENDED_INSTRUCTION_SET_ARM", static_cast(object)); + break; + case VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_NEURAL_MODEL_QCOM: + dump_enum(settings, "VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_NEURAL_MODEL_QCOM", static_cast(object)); + break; + case VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_BUILTIN_MODEL_QCOM: + dump_enum(settings, "VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_BUILTIN_MODEL_QCOM", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkBlockMatchWindowCompareModeQCOM(const VkBlockMatchWindowCompareModeQCOM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MIN_QCOM: + dump_enum(settings, "VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MIN_QCOM", static_cast(object)); + break; + case VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MAX_QCOM: + dump_enum(settings, "VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MAX_QCOM", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkCubicFilterWeightsQCOM(const VkCubicFilterWeightsQCOM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_CUBIC_FILTER_WEIGHTS_CATMULL_ROM_QCOM: + dump_enum(settings, "VK_CUBIC_FILTER_WEIGHTS_CATMULL_ROM_QCOM", static_cast(object)); + break; + case VK_CUBIC_FILTER_WEIGHTS_ZERO_TANGENT_CARDINAL_QCOM: + dump_enum(settings, "VK_CUBIC_FILTER_WEIGHTS_ZERO_TANGENT_CARDINAL_QCOM", static_cast(object)); + break; + case VK_CUBIC_FILTER_WEIGHTS_B_SPLINE_QCOM: + dump_enum(settings, "VK_CUBIC_FILTER_WEIGHTS_B_SPLINE_QCOM", static_cast(object)); + break; + case VK_CUBIC_FILTER_WEIGHTS_MITCHELL_NETRAVALI_QCOM: + dump_enum(settings, "VK_CUBIC_FILTER_WEIGHTS_MITCHELL_NETRAVALI_QCOM", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkLayeredDriverUnderlyingApiMSFT(const VkLayeredDriverUnderlyingApiMSFT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_LAYERED_DRIVER_UNDERLYING_API_NONE_MSFT: + dump_enum(settings, "VK_LAYERED_DRIVER_UNDERLYING_API_NONE_MSFT", static_cast(object)); + break; + case VK_LAYERED_DRIVER_UNDERLYING_API_D3D12_MSFT: + dump_enum(settings, "VK_LAYERED_DRIVER_UNDERLYING_API_D3D12_MSFT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkDisplaySurfaceStereoTypeNV(const VkDisplaySurfaceStereoTypeNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_DISPLAY_SURFACE_STEREO_TYPE_NONE_NV: + dump_enum(settings, "VK_DISPLAY_SURFACE_STEREO_TYPE_NONE_NV", static_cast(object)); + break; + case VK_DISPLAY_SURFACE_STEREO_TYPE_ONBOARD_DIN_NV: + dump_enum(settings, "VK_DISPLAY_SURFACE_STEREO_TYPE_ONBOARD_DIN_NV", static_cast(object)); + break; + case VK_DISPLAY_SURFACE_STEREO_TYPE_HDMI_3D_NV: + dump_enum(settings, "VK_DISPLAY_SURFACE_STEREO_TYPE_HDMI_3D_NV", static_cast(object)); + break; + case VK_DISPLAY_SURFACE_STEREO_TYPE_INBAND_DISPLAYPORT_NV: + dump_enum(settings, "VK_DISPLAY_SURFACE_STEREO_TYPE_INBAND_DISPLAYPORT_NV", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkClusterAccelerationStructureTypeNV(const VkClusterAccelerationStructureTypeNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_CLUSTERS_BOTTOM_LEVEL_NV: + dump_enum(settings, "VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_CLUSTERS_BOTTOM_LEVEL_NV", static_cast(object)); + break; + case VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_TRIANGLE_CLUSTER_NV: + dump_enum(settings, "VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_TRIANGLE_CLUSTER_NV", static_cast(object)); + break; + case VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_TRIANGLE_CLUSTER_TEMPLATE_NV: + dump_enum(settings, "VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_TRIANGLE_CLUSTER_TEMPLATE_NV", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkClusterAccelerationStructureOpTypeNV(const VkClusterAccelerationStructureOpTypeNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_MOVE_OBJECTS_NV: + dump_enum(settings, "VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_MOVE_OBJECTS_NV", static_cast(object)); + break; + case VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_CLUSTERS_BOTTOM_LEVEL_NV: + dump_enum(settings, "VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_CLUSTERS_BOTTOM_LEVEL_NV", static_cast(object)); + break; + case VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_NV: + dump_enum(settings, "VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_NV", static_cast(object)); + break; + case VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_TEMPLATE_NV: + dump_enum(settings, "VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_TEMPLATE_NV", static_cast(object)); + break; + case VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_INSTANTIATE_TRIANGLE_CLUSTER_NV: + dump_enum(settings, "VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_INSTANTIATE_TRIANGLE_CLUSTER_NV", static_cast(object)); + break; + case VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_GET_CLUSTER_TEMPLATE_INDICES_NV: + dump_enum(settings, "VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_GET_CLUSTER_TEMPLATE_INDICES_NV", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkClusterAccelerationStructureOpModeNV(const VkClusterAccelerationStructureOpModeNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_IMPLICIT_DESTINATIONS_NV: + dump_enum(settings, "VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_IMPLICIT_DESTINATIONS_NV", static_cast(object)); + break; + case VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_EXPLICIT_DESTINATIONS_NV: + dump_enum(settings, "VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_EXPLICIT_DESTINATIONS_NV", static_cast(object)); + break; + case VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_COMPUTE_SIZES_NV: + dump_enum(settings, "VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_COMPUTE_SIZES_NV", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkPartitionedAccelerationStructureOpTypeNV(const VkPartitionedAccelerationStructureOpTypeNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_WRITE_INSTANCE_NV: + dump_enum(settings, "VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_WRITE_INSTANCE_NV", static_cast(object)); + break; + case VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_UPDATE_INSTANCE_NV: + dump_enum(settings, "VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_UPDATE_INSTANCE_NV", static_cast(object)); + break; + case VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_WRITE_PARTITION_TRANSLATION_NV: + dump_enum(settings, "VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_WRITE_PARTITION_TRANSLATION_NV", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkIndirectExecutionSetInfoTypeEXT(const VkIndirectExecutionSetInfoTypeEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT: + dump_enum(settings, "VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT", static_cast(object)); + break; + case VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT: + dump_enum(settings, "VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkIndirectCommandsTokenTypeEXT(const VkIndirectCommandsTokenTypeEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXECUTION_SET_EXT: + dump_enum(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXECUTION_SET_EXT", static_cast(object)); + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT: + dump_enum(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT", static_cast(object)); + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_SEQUENCE_INDEX_EXT: + dump_enum(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_SEQUENCE_INDEX_EXT", static_cast(object)); + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_EXT: + dump_enum(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_EXT", static_cast(object)); + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT: + dump_enum(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT", static_cast(object)); + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_EXT: + dump_enum(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_EXT", static_cast(object)); + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_EXT: + dump_enum(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_EXT", static_cast(object)); + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_COUNT_EXT: + dump_enum(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_COUNT_EXT", static_cast(object)); + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_COUNT_EXT: + dump_enum(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_COUNT_EXT", static_cast(object)); + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_EXT: + dump_enum(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_EXT", static_cast(object)); + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_DATA_EXT: + dump_enum(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_DATA_EXT", static_cast(object)); + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_DATA_SEQUENCE_INDEX_EXT: + dump_enum(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_DATA_SEQUENCE_INDEX_EXT", static_cast(object)); + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV_EXT: + dump_enum(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV_EXT", static_cast(object)); + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_NV_EXT: + dump_enum(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_NV_EXT", static_cast(object)); + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_EXT: + dump_enum(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_EXT", static_cast(object)); + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_EXT: + dump_enum(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_EXT", static_cast(object)); + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_TRACE_RAYS2_EXT: + dump_enum(settings, "VK_INDIRECT_COMMANDS_TOKEN_TYPE_TRACE_RAYS2_EXT", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkDataGraphModelCacheTypeQCOM(const VkDataGraphModelCacheTypeQCOM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_DATA_GRAPH_MODEL_CACHE_TYPE_GENERIC_BINARY_QCOM: + dump_enum(settings, "VK_DATA_GRAPH_MODEL_CACHE_TYPE_GENERIC_BINARY_QCOM", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkBuildAccelerationStructureModeKHR(const VkBuildAccelerationStructureModeKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR: + dump_enum(settings, "VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR", static_cast(object)); + break; + case VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR: + dump_enum(settings, "VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkShaderGroupShaderKHR(const VkShaderGroupShaderKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + switch ((int64_t)object) { + case VK_SHADER_GROUP_SHADER_GENERAL_KHR: + dump_enum(settings, "VK_SHADER_GROUP_SHADER_GENERAL_KHR", static_cast(object)); + break; + case VK_SHADER_GROUP_SHADER_CLOSEST_HIT_KHR: + dump_enum(settings, "VK_SHADER_GROUP_SHADER_CLOSEST_HIT_KHR", static_cast(object)); + break; + case VK_SHADER_GROUP_SHADER_ANY_HIT_KHR: + dump_enum(settings, "VK_SHADER_GROUP_SHADER_ANY_HIT_KHR", static_cast(object)); + break; + case VK_SHADER_GROUP_SHADER_INTERSECTION_KHR: + dump_enum(settings, "VK_SHADER_GROUP_SHADER_INTERSECTION_KHR", static_cast(object)); + break; + default: + dump_enum_with_value(settings, "UNKNOWN", static_cast(object)); + } + dump_end(settings, OutputConstruct::value, indents); +} + +//========================= Bitmask Implementations =========================// + +template +void dump_VkAccessFlagBits(const VkAccessFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_ACCESS_INDIRECT_COMMAND_READ_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_INDIRECT_COMMAND_READ_BIT"; + is_first = false; + } + if (object & VK_ACCESS_INDEX_READ_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_INDEX_READ_BIT"; + is_first = false; + } + if (object & VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT"; + is_first = false; + } + if (object & VK_ACCESS_UNIFORM_READ_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_UNIFORM_READ_BIT"; + is_first = false; + } + if (object & VK_ACCESS_INPUT_ATTACHMENT_READ_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_INPUT_ATTACHMENT_READ_BIT"; + is_first = false; + } + if (object & VK_ACCESS_SHADER_READ_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_SHADER_READ_BIT"; + is_first = false; + } + if (object & VK_ACCESS_SHADER_WRITE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_SHADER_WRITE_BIT"; + is_first = false; + } + if (object & VK_ACCESS_COLOR_ATTACHMENT_READ_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_COLOR_ATTACHMENT_READ_BIT"; + is_first = false; + } + if (object & VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT"; + is_first = false; + } + if (object & VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT"; + is_first = false; + } + if (object & VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT"; + is_first = false; + } + if (object & VK_ACCESS_TRANSFER_READ_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_TRANSFER_READ_BIT"; + is_first = false; + } + if (object & VK_ACCESS_TRANSFER_WRITE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_TRANSFER_WRITE_BIT"; + is_first = false; + } + if (object & VK_ACCESS_HOST_READ_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_HOST_READ_BIT"; + is_first = false; + } + if (object & VK_ACCESS_HOST_WRITE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_HOST_WRITE_BIT"; + is_first = false; + } + if (object & VK_ACCESS_MEMORY_READ_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_MEMORY_READ_BIT"; + is_first = false; + } + if (object & VK_ACCESS_MEMORY_WRITE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_MEMORY_WRITE_BIT"; + is_first = false; + } + if (object == VK_ACCESS_NONE) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_NONE"; + is_first = false; + } + if (object & VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT"; + is_first = false; + } + if (object & VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT"; + is_first = false; + } + if (object & VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT"; + is_first = false; + } + if (object & VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT"; + is_first = false; + } + if (object & VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT"; + is_first = false; + } + if (object & VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR"; + is_first = false; + } + if (object & VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR"; + is_first = false; + } + if (object & VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT"; + is_first = false; + } + if (object & VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR"; + is_first = false; + } + if (object & VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_EXT"; + is_first = false; + } + if (object & VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_EXT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkImageAspectFlagBits(const VkImageAspectFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_IMAGE_ASPECT_COLOR_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_ASPECT_COLOR_BIT"; + is_first = false; + } + if (object & VK_IMAGE_ASPECT_DEPTH_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_ASPECT_DEPTH_BIT"; + is_first = false; + } + if (object & VK_IMAGE_ASPECT_STENCIL_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_ASPECT_STENCIL_BIT"; + is_first = false; + } + if (object & VK_IMAGE_ASPECT_METADATA_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_ASPECT_METADATA_BIT"; + is_first = false; + } + if (object & VK_IMAGE_ASPECT_PLANE_0_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_ASPECT_PLANE_0_BIT"; + is_first = false; + } + if (object & VK_IMAGE_ASPECT_PLANE_1_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_ASPECT_PLANE_1_BIT"; + is_first = false; + } + if (object & VK_IMAGE_ASPECT_PLANE_2_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_ASPECT_PLANE_2_BIT"; + is_first = false; + } + if (object == VK_IMAGE_ASPECT_NONE) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_ASPECT_NONE"; + is_first = false; + } + if (object & VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT"; + is_first = false; + } + if (object & VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT"; + is_first = false; + } + if (object & VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT"; + is_first = false; + } + if (object & VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkFormatFeatureFlagBits(const VkFormatFeatureFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_BLIT_SRC_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_BLIT_SRC_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_BLIT_DST_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_BLIT_DST_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_TRANSFER_SRC_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_TRANSFER_SRC_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_TRANSFER_DST_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_TRANSFER_DST_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_DISJOINT_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_DISJOINT_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkImageCreateFlagBits(const VkImageCreateFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_IMAGE_CREATE_SPARSE_BINDING_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_SPARSE_BINDING_BIT"; + is_first = false; + } + if (object & VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT"; + is_first = false; + } + if (object & VK_IMAGE_CREATE_SPARSE_ALIASED_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_SPARSE_ALIASED_BIT"; + is_first = false; + } + if (object & VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT"; + is_first = false; + } + if (object & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT"; + is_first = false; + } + if (object & VK_IMAGE_CREATE_ALIAS_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_ALIAS_BIT"; + is_first = false; + } + if (object & VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT"; + is_first = false; + } + if (object & VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT"; + is_first = false; + } + if (object & VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT"; + is_first = false; + } + if (object & VK_IMAGE_CREATE_EXTENDED_USAGE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_EXTENDED_USAGE_BIT"; + is_first = false; + } + if (object & VK_IMAGE_CREATE_PROTECTED_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_PROTECTED_BIT"; + is_first = false; + } + if (object & VK_IMAGE_CREATE_DISJOINT_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_DISJOINT_BIT"; + is_first = false; + } + if (object & VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV"; + is_first = false; + } + if (object & VK_IMAGE_CREATE_DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_EXT"; + is_first = false; + } + if (object & VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT"; + is_first = false; + } + if (object & VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT"; + is_first = false; + } + if (object & VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT"; + is_first = false; + } + if (object & VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT"; + is_first = false; + } + if (object & VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR"; + is_first = false; + } + if (object & VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkSampleCountFlagBits(const VkSampleCountFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_SAMPLE_COUNT_1_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SAMPLE_COUNT_1_BIT"; + is_first = false; + } + if (object & VK_SAMPLE_COUNT_2_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SAMPLE_COUNT_2_BIT"; + is_first = false; + } + if (object & VK_SAMPLE_COUNT_4_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SAMPLE_COUNT_4_BIT"; + is_first = false; + } + if (object & VK_SAMPLE_COUNT_8_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SAMPLE_COUNT_8_BIT"; + is_first = false; + } + if (object & VK_SAMPLE_COUNT_16_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SAMPLE_COUNT_16_BIT"; + is_first = false; + } + if (object & VK_SAMPLE_COUNT_32_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SAMPLE_COUNT_32_BIT"; + is_first = false; + } + if (object & VK_SAMPLE_COUNT_64_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SAMPLE_COUNT_64_BIT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkImageUsageFlagBits(const VkImageUsageFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_IMAGE_USAGE_TRANSFER_SRC_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_TRANSFER_SRC_BIT"; + is_first = false; + } + if (object & VK_IMAGE_USAGE_TRANSFER_DST_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_TRANSFER_DST_BIT"; + is_first = false; + } + if (object & VK_IMAGE_USAGE_SAMPLED_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_SAMPLED_BIT"; + is_first = false; + } + if (object & VK_IMAGE_USAGE_STORAGE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_STORAGE_BIT"; + is_first = false; + } + if (object & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT"; + is_first = false; + } + if (object & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT"; + is_first = false; + } + if (object & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT"; + is_first = false; + } + if (object & VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT"; + is_first = false; + } + if (object & VK_IMAGE_USAGE_HOST_TRANSFER_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_HOST_TRANSFER_BIT"; + is_first = false; + } + if (object & VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR"; + is_first = false; + } + if (object & VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR"; + is_first = false; + } + if (object & VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR"; + is_first = false; + } + if (object & VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT"; + is_first = false; + } + if (object & VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"; + is_first = false; + } + if (object & VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR"; + is_first = false; + } + if (object & VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR"; + is_first = false; + } + if (object & VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR"; + is_first = false; + } + if (object & VK_IMAGE_USAGE_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT"; + is_first = false; + } + if (object & VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI"; + is_first = false; + } + if (object & VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM"; + is_first = false; + } + if (object & VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM"; + is_first = false; + } + if (object & VK_IMAGE_USAGE_TENSOR_ALIASING_BIT_ARM) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_TENSOR_ALIASING_BIT_ARM"; + is_first = false; + } + if (object & VK_IMAGE_USAGE_TILE_MEMORY_BIT_QCOM) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_TILE_MEMORY_BIT_QCOM"; + is_first = false; + } + if (object & VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR"; + is_first = false; + } + if (object & VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkInstanceCreateFlagBits(const VkInstanceCreateFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkMemoryHeapFlagBits(const VkMemoryHeapFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_HEAP_DEVICE_LOCAL_BIT"; + is_first = false; + } + if (object & VK_MEMORY_HEAP_MULTI_INSTANCE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_HEAP_MULTI_INSTANCE_BIT"; + is_first = false; + } + if (object & VK_MEMORY_HEAP_TILE_MEMORY_BIT_QCOM) { + settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_HEAP_TILE_MEMORY_BIT_QCOM"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkMemoryPropertyFlagBits(const VkMemoryPropertyFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT"; + is_first = false; + } + if (object & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT"; + is_first = false; + } + if (object & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_PROPERTY_HOST_COHERENT_BIT"; + is_first = false; + } + if (object & VK_MEMORY_PROPERTY_HOST_CACHED_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_PROPERTY_HOST_CACHED_BIT"; + is_first = false; + } + if (object & VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT"; + is_first = false; + } + if (object & VK_MEMORY_PROPERTY_PROTECTED_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_PROPERTY_PROTECTED_BIT"; + is_first = false; + } + if (object & VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD) { + settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD"; + is_first = false; + } + if (object & VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD) { + settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD"; + is_first = false; + } + if (object & VK_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkQueueFlagBits(const VkQueueFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_QUEUE_GRAPHICS_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_QUEUE_GRAPHICS_BIT"; + is_first = false; + } + if (object & VK_QUEUE_COMPUTE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_QUEUE_COMPUTE_BIT"; + is_first = false; + } + if (object & VK_QUEUE_TRANSFER_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_QUEUE_TRANSFER_BIT"; + is_first = false; + } + if (object & VK_QUEUE_SPARSE_BINDING_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_QUEUE_SPARSE_BINDING_BIT"; + is_first = false; + } + if (object & VK_QUEUE_PROTECTED_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_QUEUE_PROTECTED_BIT"; + is_first = false; + } + if (object & VK_QUEUE_VIDEO_DECODE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_QUEUE_VIDEO_DECODE_BIT_KHR"; + is_first = false; + } + if (object & VK_QUEUE_VIDEO_ENCODE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_QUEUE_VIDEO_ENCODE_BIT_KHR"; + is_first = false; + } + if (object & VK_QUEUE_OPTICAL_FLOW_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_QUEUE_OPTICAL_FLOW_BIT_NV"; + is_first = false; + } + if (object & VK_QUEUE_DATA_GRAPH_BIT_ARM) { + settings.stream() << (is_first ? " (" : " | ") << "VK_QUEUE_DATA_GRAPH_BIT_ARM"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkDeviceQueueCreateFlagBits(const VkDeviceQueueCreateFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT"; + is_first = false; + } + if (object & VK_DEVICE_QUEUE_CREATE_INTERNALLY_SYNCHRONIZED_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DEVICE_QUEUE_CREATE_INTERNALLY_SYNCHRONIZED_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkPipelineStageFlagBits(const VkPipelineStageFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_VERTEX_INPUT_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_VERTEX_INPUT_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_VERTEX_SHADER_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_VERTEX_SHADER_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_TRANSFER_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_TRANSFER_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_HOST_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_HOST_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_ALL_COMMANDS_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_ALL_COMMANDS_BIT"; + is_first = false; + } + if (object == VK_PIPELINE_STAGE_NONE) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_NONE"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_EXT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkMemoryMapFlagBits(const VkMemoryMapFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_MEMORY_MAP_PLACED_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_MAP_PLACED_BIT_EXT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkSparseMemoryBindFlagBits(const VkSparseMemoryBindFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_SPARSE_MEMORY_BIND_METADATA_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SPARSE_MEMORY_BIND_METADATA_BIT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkSparseImageFormatFlagBits(const VkSparseImageFormatFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT"; + is_first = false; + } + if (object & VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT"; + is_first = false; + } + if (object & VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkFenceCreateFlagBits(const VkFenceCreateFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_FENCE_CREATE_SIGNALED_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FENCE_CREATE_SIGNALED_BIT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkQueryPoolCreateFlagBits(const VkQueryPoolCreateFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_QUERY_POOL_CREATE_RESET_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_POOL_CREATE_RESET_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkQueryPipelineStatisticFlagBits(const VkQueryPipelineStatisticFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT"; + is_first = false; + } + if (object & VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT"; + is_first = false; + } + if (object & VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT"; + is_first = false; + } + if (object & VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT"; + is_first = false; + } + if (object & VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT"; + is_first = false; + } + if (object & VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT"; + is_first = false; + } + if (object & VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT"; + is_first = false; + } + if (object & VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT"; + is_first = false; + } + if (object & VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT"; + is_first = false; + } + if (object & VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT"; + is_first = false; + } + if (object & VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT"; + is_first = false; + } + if (object & VK_QUERY_PIPELINE_STATISTIC_TASK_SHADER_INVOCATIONS_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_PIPELINE_STATISTIC_TASK_SHADER_INVOCATIONS_BIT_EXT"; + is_first = false; + } + if (object & VK_QUERY_PIPELINE_STATISTIC_MESH_SHADER_INVOCATIONS_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_PIPELINE_STATISTIC_MESH_SHADER_INVOCATIONS_BIT_EXT"; + is_first = false; + } + if (object & VK_QUERY_PIPELINE_STATISTIC_CLUSTER_CULLING_SHADER_INVOCATIONS_BIT_HUAWEI) { + settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_PIPELINE_STATISTIC_CLUSTER_CULLING_SHADER_INVOCATIONS_BIT_HUAWEI"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkQueryResultFlagBits(const VkQueryResultFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_QUERY_RESULT_64_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_RESULT_64_BIT"; + is_first = false; + } + if (object & VK_QUERY_RESULT_WAIT_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_RESULT_WAIT_BIT"; + is_first = false; + } + if (object & VK_QUERY_RESULT_WITH_AVAILABILITY_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_RESULT_WITH_AVAILABILITY_BIT"; + is_first = false; + } + if (object & VK_QUERY_RESULT_PARTIAL_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_RESULT_PARTIAL_BIT"; + is_first = false; + } + if (object & VK_QUERY_RESULT_WITH_STATUS_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_RESULT_WITH_STATUS_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkBufferCreateFlagBits(const VkBufferCreateFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_BUFFER_CREATE_SPARSE_BINDING_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_CREATE_SPARSE_BINDING_BIT"; + is_first = false; + } + if (object & VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT"; + is_first = false; + } + if (object & VK_BUFFER_CREATE_SPARSE_ALIASED_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_CREATE_SPARSE_ALIASED_BIT"; + is_first = false; + } + if (object & VK_BUFFER_CREATE_PROTECTED_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_CREATE_PROTECTED_BIT"; + is_first = false; + } + if (object & VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT"; + is_first = false; + } + if (object & VK_BUFFER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT"; + is_first = false; + } + if (object & VK_BUFFER_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkBufferUsageFlagBits(const VkBufferUsageFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_BUFFER_USAGE_TRANSFER_SRC_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_TRANSFER_SRC_BIT"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_TRANSFER_DST_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_TRANSFER_DST_BIT"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_STORAGE_BUFFER_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_STORAGE_BUFFER_BIT"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_INDEX_BUFFER_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_INDEX_BUFFER_BIT"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_VERTEX_BUFFER_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_VERTEX_BUFFER_BIT"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT"; + is_first = false; + } +#if defined(VK_ENABLE_BETA_EXTENSIONS) + if (object & VK_BUFFER_USAGE_EXECUTION_GRAPH_SCRATCH_BIT_AMDX) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_EXECUTION_GRAPH_SCRATCH_BIT_AMDX"; + is_first = false; + } +#endif + if (object & VK_BUFFER_USAGE_DESCRIPTOR_HEAP_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_DESCRIPTOR_HEAP_BIT_EXT"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_MICROMAP_STORAGE_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_MICROMAP_STORAGE_BIT_EXT"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_TILE_MEMORY_BIT_QCOM) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_TILE_MEMORY_BIT_QCOM"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkImageViewCreateFlagBits(const VkImageViewCreateFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT"; + is_first = false; + } + if (object & VK_IMAGE_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT"; + is_first = false; + } + if (object & VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkDependencyFlagBits(const VkDependencyFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_DEPENDENCY_BY_REGION_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DEPENDENCY_BY_REGION_BIT"; + is_first = false; + } + if (object & VK_DEPENDENCY_DEVICE_GROUP_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DEPENDENCY_DEVICE_GROUP_BIT"; + is_first = false; + } + if (object & VK_DEPENDENCY_VIEW_LOCAL_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DEPENDENCY_VIEW_LOCAL_BIT"; + is_first = false; + } + if (object & VK_DEPENDENCY_FEEDBACK_LOOP_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DEPENDENCY_FEEDBACK_LOOP_BIT_EXT"; + is_first = false; + } + if (object & VK_DEPENDENCY_QUEUE_FAMILY_OWNERSHIP_TRANSFER_USE_ALL_STAGES_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DEPENDENCY_QUEUE_FAMILY_OWNERSHIP_TRANSFER_USE_ALL_STAGES_BIT_KHR"; + is_first = false; + } + if (object & VK_DEPENDENCY_ASYMMETRIC_EVENT_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DEPENDENCY_ASYMMETRIC_EVENT_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkCommandPoolCreateFlagBits(const VkCommandPoolCreateFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_COMMAND_POOL_CREATE_TRANSIENT_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_COMMAND_POOL_CREATE_TRANSIENT_BIT"; + is_first = false; + } + if (object & VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT"; + is_first = false; + } + if (object & VK_COMMAND_POOL_CREATE_PROTECTED_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_COMMAND_POOL_CREATE_PROTECTED_BIT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkCommandPoolResetFlagBits(const VkCommandPoolResetFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkCommandBufferUsageFlagBits(const VkCommandBufferUsageFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT"; + is_first = false; + } + if (object & VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT"; + is_first = false; + } + if (object & VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkQueryControlFlagBits(const VkQueryControlFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_QUERY_CONTROL_PRECISE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_QUERY_CONTROL_PRECISE_BIT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkCommandBufferResetFlagBits(const VkCommandBufferResetFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkEventCreateFlagBits(const VkEventCreateFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_EVENT_CREATE_DEVICE_ONLY_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EVENT_CREATE_DEVICE_ONLY_BIT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkPipelineCacheCreateFlagBits(const VkPipelineCacheCreateFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_CACHE_CREATE_INTERNALLY_SYNCHRONIZED_MERGE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CACHE_CREATE_INTERNALLY_SYNCHRONIZED_MERGE_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkPipelineCreateFlagBits(const VkPipelineCreateFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_DERIVATIVE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_DERIVATIVE_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_DISPATCH_BASE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_DISPATCH_BASE_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_LIBRARY_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_LIBRARY_BIT_KHR"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT"; + is_first = false; + } +#if defined(VK_ENABLE_BETA_EXTENSIONS) + if (object & VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV"; + is_first = false; + } +#endif + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkPipelineShaderStageCreateFlagBits(const VkPipelineShaderStageCreateFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkShaderStageFlagBits(const VkShaderStageFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_SHADER_STAGE_VERTEX_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_VERTEX_BIT"; + is_first = false; + } + if (object & VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT"; + is_first = false; + } + if (object & VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT"; + is_first = false; + } + if (object & VK_SHADER_STAGE_GEOMETRY_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_GEOMETRY_BIT"; + is_first = false; + } + if (object & VK_SHADER_STAGE_FRAGMENT_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_FRAGMENT_BIT"; + is_first = false; + } + if (object & VK_SHADER_STAGE_COMPUTE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_COMPUTE_BIT"; + is_first = false; + } + if (object == VK_SHADER_STAGE_ALL_GRAPHICS) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_ALL_GRAPHICS"; + is_first = false; + } + if (object == VK_SHADER_STAGE_ALL) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_ALL"; + is_first = false; + } + if (object & VK_SHADER_STAGE_RAYGEN_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_RAYGEN_BIT_KHR"; + is_first = false; + } + if (object & VK_SHADER_STAGE_ANY_HIT_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_ANY_HIT_BIT_KHR"; + is_first = false; + } + if (object & VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR"; + is_first = false; + } + if (object & VK_SHADER_STAGE_MISS_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_MISS_BIT_KHR"; + is_first = false; + } + if (object & VK_SHADER_STAGE_INTERSECTION_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_INTERSECTION_BIT_KHR"; + is_first = false; + } + if (object & VK_SHADER_STAGE_CALLABLE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_CALLABLE_BIT_KHR"; + is_first = false; + } + if (object & VK_SHADER_STAGE_TASK_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_TASK_BIT_EXT"; + is_first = false; + } + if (object & VK_SHADER_STAGE_MESH_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_MESH_BIT_EXT"; + is_first = false; + } + if (object & VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI"; + is_first = false; + } + if (object & VK_SHADER_STAGE_CLUSTER_CULLING_BIT_HUAWEI) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_STAGE_CLUSTER_CULLING_BIT_HUAWEI"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkPipelineLayoutCreateFlagBits(const VkPipelineLayoutCreateFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkSamplerCreateFlagBits(const VkSamplerCreateFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT"; + is_first = false; + } + if (object & VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT"; + is_first = false; + } + if (object & VK_SAMPLER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SAMPLER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT"; + is_first = false; + } + if (object & VK_SAMPLER_CREATE_NON_SEAMLESS_CUBE_MAP_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SAMPLER_CREATE_NON_SEAMLESS_CUBE_MAP_BIT_EXT"; + is_first = false; + } + if (object & VK_SAMPLER_CREATE_IMAGE_PROCESSING_BIT_QCOM) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SAMPLER_CREATE_IMAGE_PROCESSING_BIT_QCOM"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkDescriptorPoolCreateFlagBits(const VkDescriptorPoolCreateFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT"; + is_first = false; + } + if (object & VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT"; + is_first = false; + } + if (object & VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT"; + is_first = false; + } + if (object & VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_SETS_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_SETS_BIT_NV"; + is_first = false; + } + if (object & VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_POOLS_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_POOLS_BIT_NV"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkDescriptorSetLayoutCreateFlagBits(const VkDescriptorSetLayoutCreateFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT"; + is_first = false; + } + if (object & VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT"; + is_first = false; + } + if (object & VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT"; + is_first = false; + } + if (object & VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT"; + is_first = false; + } + if (object & VK_DESCRIPTOR_SET_LAYOUT_CREATE_INDIRECT_BINDABLE_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_SET_LAYOUT_CREATE_INDIRECT_BINDABLE_BIT_NV"; + is_first = false; + } + if (object & VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT"; + is_first = false; + } + if (object & VK_DESCRIPTOR_SET_LAYOUT_CREATE_PER_STAGE_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_SET_LAYOUT_CREATE_PER_STAGE_BIT_NV"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkColorComponentFlagBits(const VkColorComponentFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_COLOR_COMPONENT_R_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_COLOR_COMPONENT_R_BIT"; + is_first = false; + } + if (object & VK_COLOR_COMPONENT_G_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_COLOR_COMPONENT_G_BIT"; + is_first = false; + } + if (object & VK_COLOR_COMPONENT_B_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_COLOR_COMPONENT_B_BIT"; + is_first = false; + } + if (object & VK_COLOR_COMPONENT_A_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_COLOR_COMPONENT_A_BIT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkCullModeFlagBits(const VkCullModeFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object == VK_CULL_MODE_NONE) { + settings.stream() << (is_first ? " (" : " | ") << "VK_CULL_MODE_NONE"; + is_first = false; + } + if (object & VK_CULL_MODE_FRONT_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_CULL_MODE_FRONT_BIT"; + is_first = false; + } + if (object & VK_CULL_MODE_BACK_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_CULL_MODE_BACK_BIT"; + is_first = false; + } + if (object == VK_CULL_MODE_FRONT_AND_BACK) { + settings.stream() << (is_first ? " (" : " | ") << "VK_CULL_MODE_FRONT_AND_BACK"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkPipelineDepthStencilStateCreateFlagBits(const VkPipelineDepthStencilStateCreateFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT"; + is_first = false; + } + if (object & VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkPipelineColorBlendStateCreateFlagBits(const VkPipelineColorBlendStateCreateFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkAttachmentDescriptionFlagBits(const VkAttachmentDescriptionFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT"; + is_first = false; + } + if (object & VK_ATTACHMENT_DESCRIPTION_RESOLVE_SKIP_TRANSFER_FUNCTION_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ATTACHMENT_DESCRIPTION_RESOLVE_SKIP_TRANSFER_FUNCTION_BIT_KHR"; + is_first = false; + } + if (object & VK_ATTACHMENT_DESCRIPTION_RESOLVE_ENABLE_TRANSFER_FUNCTION_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ATTACHMENT_DESCRIPTION_RESOLVE_ENABLE_TRANSFER_FUNCTION_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkFramebufferCreateFlagBits(const VkFramebufferCreateFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkRenderPassCreateFlagBits(const VkRenderPassCreateFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM) { + settings.stream() << (is_first ? " (" : " | ") << "VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM"; + is_first = false; + } + if (object & VK_RENDER_PASS_CREATE_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE) { + settings.stream() << (is_first ? " (" : " | ") << "VK_RENDER_PASS_CREATE_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkSubpassDescriptionFlagBits(const VkSubpassDescriptionFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX"; + is_first = false; + } + if (object & VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX"; + is_first = false; + } + if (object & VK_SUBPASS_DESCRIPTION_TILE_SHADING_APRON_BIT_QCOM) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SUBPASS_DESCRIPTION_TILE_SHADING_APRON_BIT_QCOM"; + is_first = false; + } + if (object & VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT"; + is_first = false; + } + if (object & VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT"; + is_first = false; + } + if (object & VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT"; + is_first = false; + } + if (object & VK_SUBPASS_DESCRIPTION_ENABLE_LEGACY_DITHERING_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SUBPASS_DESCRIPTION_ENABLE_LEGACY_DITHERING_BIT_EXT"; + is_first = false; + } + if (object & VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_EXT"; + is_first = false; + } + if (object & VK_SUBPASS_DESCRIPTION_CUSTOM_RESOLVE_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SUBPASS_DESCRIPTION_CUSTOM_RESOLVE_BIT_EXT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkStencilFaceFlagBits(const VkStencilFaceFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_STENCIL_FACE_FRONT_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_STENCIL_FACE_FRONT_BIT"; + is_first = false; + } + if (object & VK_STENCIL_FACE_BACK_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_STENCIL_FACE_BACK_BIT"; + is_first = false; + } + if (object == VK_STENCIL_FACE_FRONT_AND_BACK) { + settings.stream() << (is_first ? " (" : " | ") << "VK_STENCIL_FACE_FRONT_AND_BACK"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkPeerMemoryFeatureFlagBits(const VkPeerMemoryFeatureFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT"; + is_first = false; + } + if (object & VK_PEER_MEMORY_FEATURE_COPY_DST_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PEER_MEMORY_FEATURE_COPY_DST_BIT"; + is_first = false; + } + if (object & VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT"; + is_first = false; + } + if (object & VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkMemoryAllocateFlagBits(const VkMemoryAllocateFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT"; + is_first = false; + } + if (object & VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT"; + is_first = false; + } + if (object & VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT"; + is_first = false; + } + if (object & VK_MEMORY_ALLOCATE_ZERO_INITIALIZE_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_ALLOCATE_ZERO_INITIALIZE_BIT_EXT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkExternalMemoryHandleTypeFlagBits(const VkExternalMemoryHandleTypeFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT"; + is_first = false; + } + if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT"; + is_first = false; + } + if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT"; + is_first = false; + } + if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT"; + is_first = false; + } + if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT"; + is_first = false; + } + if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT"; + is_first = false; + } + if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT"; + is_first = false; + } + if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT"; + is_first = false; + } + if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID"; + is_first = false; + } + if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT"; + is_first = false; + } + if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT"; + is_first = false; + } + if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA"; + is_first = false; + } + if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV"; + is_first = false; + } + if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_OH_NATIVE_BUFFER_BIT_OHOS) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OH_NATIVE_BUFFER_BIT_OHOS"; + is_first = false; + } + if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCREEN_BUFFER_BIT_QNX) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCREEN_BUFFER_BIT_QNX"; + is_first = false; + } + if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLBUFFER_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLBUFFER_BIT_EXT"; + is_first = false; + } + if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLTEXTURE_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLTEXTURE_BIT_EXT"; + is_first = false; + } + if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLHEAP_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLHEAP_BIT_EXT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkExternalMemoryFeatureFlagBits(const VkExternalMemoryFeatureFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT"; + is_first = false; + } + if (object & VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT"; + is_first = false; + } + if (object & VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkExternalFenceHandleTypeFlagBits(const VkExternalFenceHandleTypeFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT"; + is_first = false; + } + if (object & VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT"; + is_first = false; + } + if (object & VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT"; + is_first = false; + } + if (object & VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkExternalFenceFeatureFlagBits(const VkExternalFenceFeatureFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT"; + is_first = false; + } + if (object & VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkFenceImportFlagBits(const VkFenceImportFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_FENCE_IMPORT_TEMPORARY_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FENCE_IMPORT_TEMPORARY_BIT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkSemaphoreImportFlagBits(const VkSemaphoreImportFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_SEMAPHORE_IMPORT_TEMPORARY_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SEMAPHORE_IMPORT_TEMPORARY_BIT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkExternalSemaphoreHandleTypeFlagBits(const VkExternalSemaphoreHandleTypeFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT"; + is_first = false; + } + if (object & VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT"; + is_first = false; + } + if (object & VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT"; + is_first = false; + } + if (object & VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT"; + is_first = false; + } + if (object & VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT"; + is_first = false; + } + if (object & VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkExternalSemaphoreFeatureFlagBits(const VkExternalSemaphoreFeatureFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT"; + is_first = false; + } + if (object & VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkSubgroupFeatureFlagBits(const VkSubgroupFeatureFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_SUBGROUP_FEATURE_BASIC_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SUBGROUP_FEATURE_BASIC_BIT"; + is_first = false; + } + if (object & VK_SUBGROUP_FEATURE_VOTE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SUBGROUP_FEATURE_VOTE_BIT"; + is_first = false; + } + if (object & VK_SUBGROUP_FEATURE_ARITHMETIC_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SUBGROUP_FEATURE_ARITHMETIC_BIT"; + is_first = false; + } + if (object & VK_SUBGROUP_FEATURE_BALLOT_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SUBGROUP_FEATURE_BALLOT_BIT"; + is_first = false; + } + if (object & VK_SUBGROUP_FEATURE_SHUFFLE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SUBGROUP_FEATURE_SHUFFLE_BIT"; + is_first = false; + } + if (object & VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT"; + is_first = false; + } + if (object & VK_SUBGROUP_FEATURE_CLUSTERED_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SUBGROUP_FEATURE_CLUSTERED_BIT"; + is_first = false; + } + if (object & VK_SUBGROUP_FEATURE_QUAD_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SUBGROUP_FEATURE_QUAD_BIT"; + is_first = false; + } + if (object & VK_SUBGROUP_FEATURE_ROTATE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SUBGROUP_FEATURE_ROTATE_BIT"; + is_first = false; + } + if (object & VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT"; + is_first = false; + } + if (object & VK_SUBGROUP_FEATURE_PARTITIONED_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SUBGROUP_FEATURE_PARTITIONED_BIT_EXT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkResolveModeFlagBits(const VkResolveModeFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object == VK_RESOLVE_MODE_NONE) { + settings.stream() << (is_first ? " (" : " | ") << "VK_RESOLVE_MODE_NONE"; + is_first = false; + } + if (object & VK_RESOLVE_MODE_SAMPLE_ZERO_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_RESOLVE_MODE_SAMPLE_ZERO_BIT"; + is_first = false; + } + if (object & VK_RESOLVE_MODE_AVERAGE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_RESOLVE_MODE_AVERAGE_BIT"; + is_first = false; + } + if (object & VK_RESOLVE_MODE_MIN_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_RESOLVE_MODE_MIN_BIT"; + is_first = false; + } + if (object & VK_RESOLVE_MODE_MAX_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_RESOLVE_MODE_MAX_BIT"; + is_first = false; + } + if (object & VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_BIT_ANDROID) { + settings.stream() << (is_first ? " (" : " | ") << "VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_BIT_ANDROID"; + is_first = false; + } + if (object & VK_RESOLVE_MODE_CUSTOM_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_RESOLVE_MODE_CUSTOM_BIT_EXT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkSemaphoreWaitFlagBits(const VkSemaphoreWaitFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_SEMAPHORE_WAIT_ANY_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SEMAPHORE_WAIT_ANY_BIT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkDescriptorBindingFlagBits(const VkDescriptorBindingFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT"; + is_first = false; + } + if (object & VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT"; + is_first = false; + } + if (object & VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT"; + is_first = false; + } + if (object & VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkToolPurposeFlagBits(const VkToolPurposeFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_TOOL_PURPOSE_VALIDATION_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_TOOL_PURPOSE_VALIDATION_BIT"; + is_first = false; + } + if (object & VK_TOOL_PURPOSE_PROFILING_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_TOOL_PURPOSE_PROFILING_BIT"; + is_first = false; + } + if (object & VK_TOOL_PURPOSE_TRACING_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_TOOL_PURPOSE_TRACING_BIT"; + is_first = false; + } + if (object & VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT"; + is_first = false; + } + if (object & VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT"; + is_first = false; + } + if (object & VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT"; + is_first = false; + } + if (object & VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkPipelineStageFlagBits2(const VkPipelineStageFlagBits2 object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object == VK_PIPELINE_STAGE_2_NONE) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_NONE"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_HOST_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_HOST_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_COPY_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_COPY_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_RESOLVE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_RESOLVE_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_BLIT_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_BLIT_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_CLEAR_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_CLEAR_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_EXT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_EXT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_EXT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_SUBPASS_SHADER_BIT_HUAWEI) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_SUBPASS_SHADER_BIT_HUAWEI"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_COPY_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_COPY_BIT_KHR"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_MICROMAP_BUILD_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_MICROMAP_BUILD_BIT_EXT"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_CLUSTER_CULLING_SHADER_BIT_HUAWEI) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_CLUSTER_CULLING_SHADER_BIT_HUAWEI"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_OPTICAL_FLOW_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_OPTICAL_FLOW_BIT_NV"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_CONVERT_COOPERATIVE_VECTOR_MATRIX_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_CONVERT_COOPERATIVE_VECTOR_MATRIX_BIT_NV"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_DATA_GRAPH_BIT_ARM) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_DATA_GRAPH_BIT_ARM"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_COPY_INDIRECT_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_COPY_INDIRECT_BIT_KHR"; + is_first = false; + } + if (object & VK_PIPELINE_STAGE_2_MEMORY_DECOMPRESSION_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_STAGE_2_MEMORY_DECOMPRESSION_BIT_EXT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkAccessFlagBits2(const VkAccessFlagBits2 object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object == VK_ACCESS_2_NONE) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_NONE"; + is_first = false; + } + if (object & VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT"; + is_first = false; + } + if (object & VK_ACCESS_2_INDEX_READ_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_INDEX_READ_BIT"; + is_first = false; + } + if (object & VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT"; + is_first = false; + } + if (object & VK_ACCESS_2_UNIFORM_READ_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_UNIFORM_READ_BIT"; + is_first = false; + } + if (object & VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT"; + is_first = false; + } + if (object & VK_ACCESS_2_SHADER_READ_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_SHADER_READ_BIT"; + is_first = false; + } + if (object & VK_ACCESS_2_SHADER_WRITE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_SHADER_WRITE_BIT"; + is_first = false; + } + if (object & VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT"; + is_first = false; + } + if (object & VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT"; + is_first = false; + } + if (object & VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT"; + is_first = false; + } + if (object & VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT"; + is_first = false; + } + if (object & VK_ACCESS_2_TRANSFER_READ_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_TRANSFER_READ_BIT"; + is_first = false; + } + if (object & VK_ACCESS_2_TRANSFER_WRITE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_TRANSFER_WRITE_BIT"; + is_first = false; + } + if (object & VK_ACCESS_2_HOST_READ_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_HOST_READ_BIT"; + is_first = false; + } + if (object & VK_ACCESS_2_HOST_WRITE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_HOST_WRITE_BIT"; + is_first = false; + } + if (object & VK_ACCESS_2_MEMORY_READ_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_MEMORY_READ_BIT"; + is_first = false; + } + if (object & VK_ACCESS_2_MEMORY_WRITE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_MEMORY_WRITE_BIT"; + is_first = false; + } + if (object & VK_ACCESS_2_SHADER_SAMPLED_READ_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_SHADER_SAMPLED_READ_BIT"; + is_first = false; + } + if (object & VK_ACCESS_2_SHADER_STORAGE_READ_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_SHADER_STORAGE_READ_BIT"; + is_first = false; + } + if (object & VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT"; + is_first = false; + } + if (object & VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR"; + is_first = false; + } + if (object & VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR"; + is_first = false; + } + if (object & VK_ACCESS_2_SAMPLER_HEAP_READ_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_SAMPLER_HEAP_READ_BIT_EXT"; + is_first = false; + } + if (object & VK_ACCESS_2_RESOURCE_HEAP_READ_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_RESOURCE_HEAP_READ_BIT_EXT"; + is_first = false; + } + if (object & VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR"; + is_first = false; + } + if (object & VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR"; + is_first = false; + } + if (object & VK_ACCESS_2_SHADER_TILE_ATTACHMENT_READ_BIT_QCOM) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_SHADER_TILE_ATTACHMENT_READ_BIT_QCOM"; + is_first = false; + } + if (object & VK_ACCESS_2_SHADER_TILE_ATTACHMENT_WRITE_BIT_QCOM) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_SHADER_TILE_ATTACHMENT_WRITE_BIT_QCOM"; + is_first = false; + } + if (object & VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT"; + is_first = false; + } + if (object & VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT"; + is_first = false; + } + if (object & VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT"; + is_first = false; + } + if (object & VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT"; + is_first = false; + } + if (object & VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_EXT"; + is_first = false; + } + if (object & VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_EXT"; + is_first = false; + } + if (object & VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR"; + is_first = false; + } + if (object & VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR"; + is_first = false; + } + if (object & VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR"; + is_first = false; + } + if (object & VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT"; + is_first = false; + } + if (object & VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT"; + is_first = false; + } + if (object & VK_ACCESS_2_DESCRIPTOR_BUFFER_READ_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_DESCRIPTOR_BUFFER_READ_BIT_EXT"; + is_first = false; + } + if (object & VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI"; + is_first = false; + } + if (object & VK_ACCESS_2_SHADER_BINDING_TABLE_READ_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_SHADER_BINDING_TABLE_READ_BIT_KHR"; + is_first = false; + } + if (object & VK_ACCESS_2_MICROMAP_READ_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_MICROMAP_READ_BIT_EXT"; + is_first = false; + } + if (object & VK_ACCESS_2_MICROMAP_WRITE_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_MICROMAP_WRITE_BIT_EXT"; + is_first = false; + } + if (object & VK_ACCESS_2_OPTICAL_FLOW_READ_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_OPTICAL_FLOW_READ_BIT_NV"; + is_first = false; + } + if (object & VK_ACCESS_2_OPTICAL_FLOW_WRITE_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_OPTICAL_FLOW_WRITE_BIT_NV"; + is_first = false; + } + if (object & VK_ACCESS_2_DATA_GRAPH_READ_BIT_ARM) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_DATA_GRAPH_READ_BIT_ARM"; + is_first = false; + } + if (object & VK_ACCESS_2_DATA_GRAPH_WRITE_BIT_ARM) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_DATA_GRAPH_WRITE_BIT_ARM"; + is_first = false; + } + if (object & VK_ACCESS_2_MEMORY_DECOMPRESSION_READ_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_MEMORY_DECOMPRESSION_READ_BIT_EXT"; + is_first = false; + } + if (object & VK_ACCESS_2_MEMORY_DECOMPRESSION_WRITE_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_2_MEMORY_DECOMPRESSION_WRITE_BIT_EXT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkSubmitFlagBits(const VkSubmitFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_SUBMIT_PROTECTED_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SUBMIT_PROTECTED_BIT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkFormatFeatureFlagBits2(const VkFormatFeatureFlagBits2 object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_BLIT_SRC_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_BLIT_SRC_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_BLIT_DST_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_BLIT_DST_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_DISJOINT_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_DISJOINT_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_RADIUS_BUFFER_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_RADIUS_BUFFER_BIT_NV"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_WEIGHT_IMAGE_BIT_QCOM) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_WEIGHT_IMAGE_BIT_QCOM"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_BLOCK_MATCHING_BIT_QCOM) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_BLOCK_MATCHING_BIT_QCOM"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_BOX_FILTER_SAMPLED_BIT_QCOM) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_BOX_FILTER_SAMPLED_BIT_QCOM"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_TENSOR_SHADER_BIT_ARM) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_TENSOR_SHADER_BIT_ARM"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_TENSOR_IMAGE_ALIASING_BIT_ARM) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_TENSOR_IMAGE_ALIASING_BIT_ARM"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_TENSOR_DATA_GRAPH_BIT_ARM) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_TENSOR_DATA_GRAPH_BIT_ARM"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_COPY_IMAGE_INDIRECT_DST_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_COPY_IMAGE_INDIRECT_DST_BIT_KHR"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_COMPUTE_QUEUE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_COMPUTE_QUEUE_BIT_KHR"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_TRANSFER_QUEUE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_TRANSFER_QUEUE_BIT_KHR"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_COMPUTE_QUEUE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_COMPUTE_QUEUE_BIT_KHR"; + is_first = false; + } + if (object & VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_TRANSFER_QUEUE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_TRANSFER_QUEUE_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkPipelineCreationFeedbackFlagBits(const VkPipelineCreationFeedbackFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkRenderingFlagBits(const VkRenderingFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT"; + is_first = false; + } + if (object & VK_RENDERING_SUSPENDING_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_RENDERING_SUSPENDING_BIT"; + is_first = false; + } + if (object & VK_RENDERING_RESUMING_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_RENDERING_RESUMING_BIT"; + is_first = false; + } + if (object & VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT"; + is_first = false; + } + if (object & VK_RENDERING_CONTENTS_INLINE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_RENDERING_CONTENTS_INLINE_BIT_KHR"; + is_first = false; + } + if (object & VK_RENDERING_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE) { + settings.stream() << (is_first ? " (" : " | ") << "VK_RENDERING_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE"; + is_first = false; + } + if (object & VK_RENDERING_FRAGMENT_REGION_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_RENDERING_FRAGMENT_REGION_BIT_EXT"; + is_first = false; + } + if (object & VK_RENDERING_CUSTOM_RESOLVE_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_RENDERING_CUSTOM_RESOLVE_BIT_EXT"; + is_first = false; + } + if (object & VK_RENDERING_LOCAL_READ_CONCURRENT_ACCESS_CONTROL_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_RENDERING_LOCAL_READ_CONCURRENT_ACCESS_CONTROL_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkMemoryUnmapFlagBits(const VkMemoryUnmapFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_MEMORY_UNMAP_RESERVE_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_UNMAP_RESERVE_BIT_EXT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkBufferUsageFlagBits2(const VkBufferUsageFlagBits2 object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_2_TRANSFER_DST_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_TRANSFER_DST_BIT"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT"; + is_first = false; + } +#if defined(VK_ENABLE_BETA_EXTENSIONS) + if (object & VK_BUFFER_USAGE_2_EXECUTION_GRAPH_SCRATCH_BIT_AMDX) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_EXECUTION_GRAPH_SCRATCH_BIT_AMDX"; + is_first = false; + } +#endif + if (object & VK_BUFFER_USAGE_2_DESCRIPTOR_HEAP_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_DESCRIPTOR_HEAP_BIT_EXT"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_2_CONDITIONAL_RENDERING_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_CONDITIONAL_RENDERING_BIT_EXT"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_2_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT"; + is_first = false; + } +#if defined(VK_ENABLE_BETA_EXTENSIONS) + if (object & VK_BUFFER_USAGE_2_COMPRESSED_DATA_DGF1_BIT_AMDX) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_COMPRESSED_DATA_DGF1_BIT_AMDX"; + is_first = false; + } +#endif + if (object & VK_BUFFER_USAGE_2_DATA_GRAPH_FOREIGN_DESCRIPTOR_BIT_ARM) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_DATA_GRAPH_FOREIGN_DESCRIPTOR_BIT_ARM"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_2_TILE_MEMORY_BIT_QCOM) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_TILE_MEMORY_BIT_QCOM"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_2_MEMORY_DECOMPRESSION_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_MEMORY_DECOMPRESSION_BIT_EXT"; + is_first = false; + } + if (object & VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkHostImageCopyFlagBits(const VkHostImageCopyFlagBits object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_HOST_IMAGE_COPY_MEMCPY_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_HOST_IMAGE_COPY_MEMCPY_BIT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkPipelineCreateFlagBits2(const VkPipelineCreateFlagBits2 object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_2_DERIVATIVE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_DERIVATIVE_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT"; + is_first = false; + } +#if defined(VK_ENABLE_BETA_EXTENSIONS) + if (object & VK_PIPELINE_CREATE_2_EXECUTION_GRAPH_BIT_AMDX) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_EXECUTION_GRAPH_BIT_AMDX"; + is_first = false; + } +#endif + if (object & VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_SPHERES_AND_LINEAR_SWEPT_SPHERES_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_SPHERES_AND_LINEAR_SWEPT_SPHERES_BIT_NV"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_2_CAPTURE_STATISTICS_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_CAPTURE_STATISTICS_BIT_KHR"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_2_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_2_LINK_TIME_OPTIMIZATION_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_LINK_TIME_OPTIMIZATION_BIT_EXT"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_2_LIBRARY_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_LIBRARY_BIT_KHR"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_AABBS_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_AABBS_BIT_KHR"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_NV"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_MOTION_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_MOTION_BIT_NV"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_2_DISALLOW_OPACITY_MICROMAP_BIT_ARM) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_DISALLOW_OPACITY_MICROMAP_BIT_ARM"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_2_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE"; + is_first = false; + } + if (object & VK_PIPELINE_CREATE_2_64_BIT_INDEXING_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PIPELINE_CREATE_2_64_BIT_INDEXING_BIT_EXT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkSurfaceTransformFlagBitsKHR(const VkSurfaceTransformFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR"; + is_first = false; + } + if (object & VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR"; + is_first = false; + } + if (object & VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR"; + is_first = false; + } + if (object & VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR"; + is_first = false; + } + if (object & VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR"; + is_first = false; + } + if (object & VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR"; + is_first = false; + } + if (object & VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR"; + is_first = false; + } + if (object & VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR"; + is_first = false; + } + if (object & VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkCompositeAlphaFlagBitsKHR(const VkCompositeAlphaFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR"; + is_first = false; + } + if (object & VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR"; + is_first = false; + } + if (object & VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR"; + is_first = false; + } + if (object & VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkSwapchainCreateFlagBitsKHR(const VkSwapchainCreateFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR"; + is_first = false; + } + if (object & VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR"; + is_first = false; + } + if (object & VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR"; + is_first = false; + } + if (object & VK_SWAPCHAIN_CREATE_PRESENT_TIMING_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SWAPCHAIN_CREATE_PRESENT_TIMING_BIT_EXT"; + is_first = false; + } + if (object & VK_SWAPCHAIN_CREATE_PRESENT_ID_2_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SWAPCHAIN_CREATE_PRESENT_ID_2_BIT_KHR"; + is_first = false; + } + if (object & VK_SWAPCHAIN_CREATE_PRESENT_WAIT_2_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SWAPCHAIN_CREATE_PRESENT_WAIT_2_BIT_KHR"; + is_first = false; + } + if (object & VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkDeviceGroupPresentModeFlagBitsKHR(const VkDeviceGroupPresentModeFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR"; + is_first = false; + } + if (object & VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR"; + is_first = false; + } + if (object & VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR"; + is_first = false; + } + if (object & VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkDisplayPlaneAlphaFlagBitsKHR(const VkDisplayPlaneAlphaFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR"; + is_first = false; + } + if (object & VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR"; + is_first = false; + } + if (object & VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR"; + is_first = false; + } + if (object & VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkVideoCodecOperationFlagBitsKHR(const VkVideoCodecOperationFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object == VK_VIDEO_CODEC_OPERATION_NONE_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CODEC_OPERATION_NONE_KHR"; + is_first = false; + } + if (object & VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkVideoChromaSubsamplingFlagBitsKHR(const VkVideoChromaSubsamplingFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object == VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_KHR"; + is_first = false; + } + if (object & VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkVideoComponentBitDepthFlagBitsKHR(const VkVideoComponentBitDepthFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object == VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR"; + is_first = false; + } + if (object & VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkVideoCapabilityFlagBitsKHR(const VkVideoCapabilityFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkVideoSessionCreateFlagBitsKHR(const VkVideoSessionCreateFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_EMPHASIS_MAP_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_EMPHASIS_MAP_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_SESSION_CREATE_INLINE_SESSION_PARAMETERS_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_SESSION_CREATE_INLINE_SESSION_PARAMETERS_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkVideoSessionParametersCreateFlagBitsKHR(const VkVideoSessionParametersCreateFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_VIDEO_SESSION_PARAMETERS_CREATE_QUANTIZATION_MAP_COMPATIBLE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_SESSION_PARAMETERS_CREATE_QUANTIZATION_MAP_COMPATIBLE_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkVideoCodingControlFlagBitsKHR(const VkVideoCodingControlFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_CODING_CONTROL_ENCODE_QUALITY_LEVEL_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_CODING_CONTROL_ENCODE_QUALITY_LEVEL_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkVideoDecodeCapabilityFlagBitsKHR(const VkVideoDecodeCapabilityFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkVideoDecodeUsageFlagBitsKHR(const VkVideoDecodeUsageFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object == VK_VIDEO_DECODE_USAGE_DEFAULT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_DECODE_USAGE_DEFAULT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_DECODE_USAGE_TRANSCODING_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_DECODE_USAGE_TRANSCODING_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_DECODE_USAGE_OFFLINE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_DECODE_USAGE_OFFLINE_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_DECODE_USAGE_STREAMING_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_DECODE_USAGE_STREAMING_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkVideoEncodeH264CapabilityFlagBitsKHR(const VkVideoEncodeH264CapabilityFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H264_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H264_CAPABILITY_MB_QP_DIFF_WRAPAROUND_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_CAPABILITY_MB_QP_DIFF_WRAPAROUND_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkVideoEncodeH264StdFlagBitsKHR(const VkVideoEncodeH264StdFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_VIDEO_ENCODE_H264_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H264_STD_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H264_STD_SCALING_MATRIX_PRESENT_FLAG_SET_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_SCALING_MATRIX_PRESENT_FLAG_SET_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H264_STD_CHROMA_QP_INDEX_OFFSET_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_CHROMA_QP_INDEX_OFFSET_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H264_STD_SECOND_CHROMA_QP_INDEX_OFFSET_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_SECOND_CHROMA_QP_INDEX_OFFSET_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H264_STD_PIC_INIT_QP_MINUS26_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_PIC_INIT_QP_MINUS26_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H264_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_EXPLICIT_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_EXPLICIT_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_IMPLICIT_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_IMPLICIT_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H264_STD_TRANSFORM_8X8_MODE_FLAG_SET_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_TRANSFORM_8X8_MODE_FLAG_SET_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H264_STD_DIRECT_SPATIAL_MV_PRED_FLAG_UNSET_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_DIRECT_SPATIAL_MV_PRED_FLAG_UNSET_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_UNSET_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_UNSET_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_SET_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_SET_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H264_STD_DIRECT_8X8_INFERENCE_FLAG_UNSET_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_DIRECT_8X8_INFERENCE_FLAG_UNSET_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H264_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H264_STD_SLICE_QP_DELTA_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_SLICE_QP_DELTA_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H264_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkVideoEncodeH264RateControlFlagBitsKHR(const VkVideoEncodeH264RateControlFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_VIDEO_ENCODE_H264_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H264_RATE_CONTROL_REGULAR_GOP_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_RATE_CONTROL_REGULAR_GOP_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H264_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H264_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkVideoEncodeH265CapabilityFlagBitsKHR(const VkVideoEncodeH265CapabilityFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H265_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H265_CAPABILITY_CU_QP_DIFF_WRAPAROUND_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CAPABILITY_CU_QP_DIFF_WRAPAROUND_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkVideoEncodeH265StdFlagBitsKHR(const VkVideoEncodeH265StdFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_VIDEO_ENCODE_H265_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H265_STD_SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H265_STD_SCALING_LIST_DATA_PRESENT_FLAG_SET_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_SCALING_LIST_DATA_PRESENT_FLAG_SET_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H265_STD_PCM_ENABLED_FLAG_SET_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_PCM_ENABLED_FLAG_SET_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H265_STD_SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H265_STD_INIT_QP_MINUS26_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_INIT_QP_MINUS26_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H265_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H265_STD_WEIGHTED_BIPRED_FLAG_SET_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_WEIGHTED_BIPRED_FLAG_SET_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H265_STD_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H265_STD_SIGN_DATA_HIDING_ENABLED_FLAG_SET_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_SIGN_DATA_HIDING_ENABLED_FLAG_SET_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_SET_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_SET_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_UNSET_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_UNSET_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H265_STD_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H265_STD_TRANSQUANT_BYPASS_ENABLED_FLAG_SET_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_TRANSQUANT_BYPASS_ENABLED_FLAG_SET_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H265_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H265_STD_ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H265_STD_SLICE_QP_DELTA_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_SLICE_QP_DELTA_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H265_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkVideoEncodeH265CtbSizeFlagBitsKHR(const VkVideoEncodeH265CtbSizeFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkVideoEncodeH265TransformBlockSizeFlagBitsKHR(const VkVideoEncodeH265TransformBlockSizeFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkVideoEncodeH265RateControlFlagBitsKHR(const VkVideoEncodeH265RateControlFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_VIDEO_ENCODE_H265_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H265_RATE_CONTROL_REGULAR_GOP_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_RATE_CONTROL_REGULAR_GOP_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_H265_RATE_CONTROL_TEMPORAL_SUB_LAYER_PATTERN_DYADIC_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_H265_RATE_CONTROL_TEMPORAL_SUB_LAYER_PATTERN_DYADIC_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkVideoDecodeH264PictureLayoutFlagBitsKHR(const VkVideoDecodeH264PictureLayoutFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object == VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR"; + is_first = false; + } + if (object & VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkPerformanceCounterDescriptionFlagBitsKHR(const VkPerformanceCounterDescriptionFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR"; + is_first = false; + } + if (object & VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkAcquireProfilingLockFlagBitsKHR(const VkAcquireProfilingLockFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkVideoEncodeFlagBitsKHR(const VkVideoEncodeFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_VIDEO_ENCODE_INTRA_REFRESH_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_INTRA_REFRESH_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_WITH_QUANTIZATION_DELTA_MAP_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_WITH_QUANTIZATION_DELTA_MAP_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_WITH_EMPHASIS_MAP_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_WITH_EMPHASIS_MAP_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkVideoEncodeCapabilityFlagBitsKHR(const VkVideoEncodeCapabilityFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_CAPABILITY_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_CAPABILITY_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkVideoEncodeRateControlModeFlagBitsKHR(const VkVideoEncodeRateControlModeFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object == VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DEFAULT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DEFAULT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkVideoEncodeFeedbackFlagBitsKHR(const VkVideoEncodeFeedbackFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_HAS_OVERRIDES_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_HAS_OVERRIDES_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkVideoEncodeUsageFlagBitsKHR(const VkVideoEncodeUsageFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object == VK_VIDEO_ENCODE_USAGE_DEFAULT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_USAGE_DEFAULT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_USAGE_TRANSCODING_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_USAGE_TRANSCODING_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_USAGE_STREAMING_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_USAGE_STREAMING_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_USAGE_RECORDING_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_USAGE_RECORDING_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_USAGE_CONFERENCING_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_USAGE_CONFERENCING_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkVideoEncodeContentFlagBitsKHR(const VkVideoEncodeContentFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object == VK_VIDEO_ENCODE_CONTENT_DEFAULT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_CONTENT_DEFAULT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_CONTENT_CAMERA_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_CONTENT_CAMERA_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_CONTENT_DESKTOP_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_CONTENT_DESKTOP_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_CONTENT_RENDERED_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_CONTENT_RENDERED_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkPresentScalingFlagBitsKHR(const VkPresentScalingFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_PRESENT_SCALING_ONE_TO_ONE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PRESENT_SCALING_ONE_TO_ONE_BIT_KHR"; + is_first = false; + } + if (object & VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_KHR"; + is_first = false; + } + if (object & VK_PRESENT_SCALING_STRETCH_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PRESENT_SCALING_STRETCH_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkPresentGravityFlagBitsKHR(const VkPresentGravityFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_PRESENT_GRAVITY_MIN_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PRESENT_GRAVITY_MIN_BIT_KHR"; + is_first = false; + } + if (object & VK_PRESENT_GRAVITY_MAX_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PRESENT_GRAVITY_MAX_BIT_KHR"; + is_first = false; + } + if (object & VK_PRESENT_GRAVITY_CENTERED_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PRESENT_GRAVITY_CENTERED_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkVideoEncodeAV1CapabilityFlagBitsKHR(const VkVideoEncodeAV1CapabilityFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_VIDEO_ENCODE_AV1_CAPABILITY_PER_RATE_CONTROL_GROUP_MIN_MAX_Q_INDEX_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_CAPABILITY_PER_RATE_CONTROL_GROUP_MIN_MAX_Q_INDEX_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_AV1_CAPABILITY_GENERATE_OBU_EXTENSION_HEADER_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_CAPABILITY_GENERATE_OBU_EXTENSION_HEADER_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_AV1_CAPABILITY_PRIMARY_REFERENCE_CDF_ONLY_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_CAPABILITY_PRIMARY_REFERENCE_CDF_ONLY_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_AV1_CAPABILITY_FRAME_SIZE_OVERRIDE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_CAPABILITY_FRAME_SIZE_OVERRIDE_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_AV1_CAPABILITY_MOTION_VECTOR_SCALING_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_CAPABILITY_MOTION_VECTOR_SCALING_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_AV1_CAPABILITY_COMPOUND_PREDICTION_INTRA_REFRESH_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_CAPABILITY_COMPOUND_PREDICTION_INTRA_REFRESH_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkVideoEncodeAV1StdFlagBitsKHR(const VkVideoEncodeAV1StdFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_VIDEO_ENCODE_AV1_STD_UNIFORM_TILE_SPACING_FLAG_SET_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_STD_UNIFORM_TILE_SPACING_FLAG_SET_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_AV1_STD_SKIP_MODE_PRESENT_UNSET_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_STD_SKIP_MODE_PRESENT_UNSET_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_AV1_STD_PRIMARY_REF_FRAME_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_STD_PRIMARY_REF_FRAME_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_AV1_STD_DELTA_Q_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_STD_DELTA_Q_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkVideoEncodeAV1SuperblockSizeFlagBitsKHR(const VkVideoEncodeAV1SuperblockSizeFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_64_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_64_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_128_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_128_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkVideoEncodeAV1RateControlFlagBitsKHR(const VkVideoEncodeAV1RateControlFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REGULAR_GOP_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REGULAR_GOP_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_AV1_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkAddressCopyFlagBitsKHR(const VkAddressCopyFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_ADDRESS_COPY_DEVICE_LOCAL_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ADDRESS_COPY_DEVICE_LOCAL_BIT_KHR"; + is_first = false; + } + if (object & VK_ADDRESS_COPY_SPARSE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ADDRESS_COPY_SPARSE_BIT_KHR"; + is_first = false; + } + if (object & VK_ADDRESS_COPY_PROTECTED_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ADDRESS_COPY_PROTECTED_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkVideoEncodeIntraRefreshModeFlagBitsKHR(const VkVideoEncodeIntraRefreshModeFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object == VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_NONE_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_NONE_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_PER_PICTURE_PARTITION_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_PER_PICTURE_PARTITION_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_BASED_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_BASED_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_ROW_BASED_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_ROW_BASED_BIT_KHR"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_COLUMN_BASED_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_COLUMN_BASED_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkAccessFlagBits3KHR(const VkAccessFlagBits3KHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object == VK_ACCESS_3_NONE_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCESS_3_NONE_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkRenderingAttachmentFlagBitsKHR(const VkRenderingAttachmentFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_RENDERING_ATTACHMENT_INPUT_ATTACHMENT_FEEDBACK_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_RENDERING_ATTACHMENT_INPUT_ATTACHMENT_FEEDBACK_BIT_KHR"; + is_first = false; + } + if (object & VK_RENDERING_ATTACHMENT_RESOLVE_SKIP_TRANSFER_FUNCTION_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_RENDERING_ATTACHMENT_RESOLVE_SKIP_TRANSFER_FUNCTION_BIT_KHR"; + is_first = false; + } + if (object & VK_RENDERING_ATTACHMENT_RESOLVE_ENABLE_TRANSFER_FUNCTION_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_RENDERING_ATTACHMENT_RESOLVE_ENABLE_TRANSFER_FUNCTION_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkResolveImageFlagBitsKHR(const VkResolveImageFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_RESOLVE_IMAGE_SKIP_TRANSFER_FUNCTION_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_RESOLVE_IMAGE_SKIP_TRANSFER_FUNCTION_BIT_KHR"; + is_first = false; + } + if (object & VK_RESOLVE_IMAGE_ENABLE_TRANSFER_FUNCTION_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_RESOLVE_IMAGE_ENABLE_TRANSFER_FUNCTION_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkDebugReportFlagBitsEXT(const VkDebugReportFlagBitsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_DEBUG_REPORT_INFORMATION_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DEBUG_REPORT_INFORMATION_BIT_EXT"; + is_first = false; + } + if (object & VK_DEBUG_REPORT_WARNING_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DEBUG_REPORT_WARNING_BIT_EXT"; + is_first = false; + } + if (object & VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT"; + is_first = false; + } + if (object & VK_DEBUG_REPORT_ERROR_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DEBUG_REPORT_ERROR_BIT_EXT"; + is_first = false; + } + if (object & VK_DEBUG_REPORT_DEBUG_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DEBUG_REPORT_DEBUG_BIT_EXT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkExternalMemoryHandleTypeFlagBitsNV(const VkExternalMemoryHandleTypeFlagBitsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV"; + is_first = false; + } + if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV"; + is_first = false; + } + if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV"; + is_first = false; + } + if (object & VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkExternalMemoryFeatureFlagBitsNV(const VkExternalMemoryFeatureFlagBitsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV"; + is_first = false; + } + if (object & VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV"; + is_first = false; + } + if (object & VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkConditionalRenderingFlagBitsEXT(const VkConditionalRenderingFlagBitsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkSurfaceCounterFlagBitsEXT(const VkSurfaceCounterFlagBitsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_SURFACE_COUNTER_VBLANK_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SURFACE_COUNTER_VBLANK_BIT_EXT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkDebugUtilsMessageSeverityFlagBitsEXT(const VkDebugUtilsMessageSeverityFlagBitsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT"; + is_first = false; + } + if (object & VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT"; + is_first = false; + } + if (object & VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT"; + is_first = false; + } + if (object & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkDebugUtilsMessageTypeFlagBitsEXT(const VkDebugUtilsMessageTypeFlagBitsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT"; + is_first = false; + } + if (object & VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT"; + is_first = false; + } + if (object & VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT"; + is_first = false; + } + if (object & VK_DEBUG_UTILS_MESSAGE_TYPE_DEVICE_ADDRESS_BINDING_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DEBUG_UTILS_MESSAGE_TYPE_DEVICE_ADDRESS_BINDING_BIT_EXT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkTensorViewCreateFlagBitsARM(const VkTensorViewCreateFlagBitsARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_TENSOR_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM) { + settings.stream() << (is_first ? " (" : " | ") << "VK_TENSOR_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkSpirvResourceTypeFlagBitsEXT(const VkSpirvResourceTypeFlagBitsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object == VK_SPIRV_RESOURCE_TYPE_ALL_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SPIRV_RESOURCE_TYPE_ALL_EXT"; + is_first = false; + } + if (object & VK_SPIRV_RESOURCE_TYPE_SAMPLER_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SPIRV_RESOURCE_TYPE_SAMPLER_BIT_EXT"; + is_first = false; + } + if (object & VK_SPIRV_RESOURCE_TYPE_SAMPLED_IMAGE_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SPIRV_RESOURCE_TYPE_SAMPLED_IMAGE_BIT_EXT"; + is_first = false; + } + if (object & VK_SPIRV_RESOURCE_TYPE_READ_ONLY_IMAGE_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SPIRV_RESOURCE_TYPE_READ_ONLY_IMAGE_BIT_EXT"; + is_first = false; + } + if (object & VK_SPIRV_RESOURCE_TYPE_READ_WRITE_IMAGE_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SPIRV_RESOURCE_TYPE_READ_WRITE_IMAGE_BIT_EXT"; + is_first = false; + } + if (object & VK_SPIRV_RESOURCE_TYPE_COMBINED_SAMPLED_IMAGE_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SPIRV_RESOURCE_TYPE_COMBINED_SAMPLED_IMAGE_BIT_EXT"; + is_first = false; + } + if (object & VK_SPIRV_RESOURCE_TYPE_UNIFORM_BUFFER_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SPIRV_RESOURCE_TYPE_UNIFORM_BUFFER_BIT_EXT"; + is_first = false; + } + if (object & VK_SPIRV_RESOURCE_TYPE_READ_ONLY_STORAGE_BUFFER_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SPIRV_RESOURCE_TYPE_READ_ONLY_STORAGE_BUFFER_BIT_EXT"; + is_first = false; + } + if (object & VK_SPIRV_RESOURCE_TYPE_READ_WRITE_STORAGE_BUFFER_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SPIRV_RESOURCE_TYPE_READ_WRITE_STORAGE_BUFFER_BIT_EXT"; + is_first = false; + } + if (object & VK_SPIRV_RESOURCE_TYPE_ACCELERATION_STRUCTURE_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SPIRV_RESOURCE_TYPE_ACCELERATION_STRUCTURE_BIT_EXT"; + is_first = false; + } + if (object & VK_SPIRV_RESOURCE_TYPE_TENSOR_BIT_ARM) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SPIRV_RESOURCE_TYPE_TENSOR_BIT_ARM"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkGeometryFlagBitsKHR(const VkGeometryFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_GEOMETRY_OPAQUE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_GEOMETRY_OPAQUE_BIT_KHR"; + is_first = false; + } + if (object & VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkGeometryInstanceFlagBitsKHR(const VkGeometryInstanceFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR"; + is_first = false; + } + if (object & VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR"; + is_first = false; + } + if (object & VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR"; + is_first = false; + } + if (object & VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR"; + is_first = false; + } + if (object & VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT"; + is_first = false; + } + if (object & VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkBuildAccelerationStructureFlagBitsKHR(const VkBuildAccelerationStructureFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR"; + is_first = false; + } + if (object & VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR"; + is_first = false; + } + if (object & VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR"; + is_first = false; + } + if (object & VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR"; + is_first = false; + } + if (object & VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR"; + is_first = false; + } + if (object & VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV"; + is_first = false; + } + if (object & VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT"; + is_first = false; + } + if (object & VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT"; + is_first = false; + } + if (object & VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_BIT_EXT"; + is_first = false; + } +#if defined(VK_ENABLE_BETA_EXTENSIONS) + if (object & VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_BIT_NV"; + is_first = false; + } +#endif + if (object & VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR"; + is_first = false; + } + if (object & VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_CLUSTER_OPACITY_MICROMAPS_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_CLUSTER_OPACITY_MICROMAPS_BIT_NV"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkPipelineCompilerControlFlagBitsAMD(const VkPipelineCompilerControlFlagBitsAMD object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkPresentStageFlagBitsEXT(const VkPresentStageFlagBitsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_PRESENT_STAGE_QUEUE_OPERATIONS_END_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PRESENT_STAGE_QUEUE_OPERATIONS_END_BIT_EXT"; + is_first = false; + } + if (object & VK_PRESENT_STAGE_REQUEST_DEQUEUED_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PRESENT_STAGE_REQUEST_DEQUEUED_BIT_EXT"; + is_first = false; + } + if (object & VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_OUT_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_OUT_BIT_EXT"; + is_first = false; + } + if (object & VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_VISIBLE_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_VISIBLE_BIT_EXT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkPastPresentationTimingFlagBitsEXT(const VkPastPresentationTimingFlagBitsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_PAST_PRESENTATION_TIMING_ALLOW_PARTIAL_RESULTS_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PAST_PRESENTATION_TIMING_ALLOW_PARTIAL_RESULTS_BIT_EXT"; + is_first = false; + } + if (object & VK_PAST_PRESENTATION_TIMING_ALLOW_OUT_OF_ORDER_RESULTS_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PAST_PRESENTATION_TIMING_ALLOW_OUT_OF_ORDER_RESULTS_BIT_EXT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkPresentTimingInfoFlagBitsEXT(const VkPresentTimingInfoFlagBitsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_PRESENT_TIMING_INFO_PRESENT_AT_RELATIVE_TIME_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PRESENT_TIMING_INFO_PRESENT_AT_RELATIVE_TIME_BIT_EXT"; + is_first = false; + } + if (object & VK_PRESENT_TIMING_INFO_PRESENT_AT_NEAREST_REFRESH_CYCLE_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PRESENT_TIMING_INFO_PRESENT_AT_NEAREST_REFRESH_CYCLE_BIT_EXT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkShaderCorePropertiesFlagBitsAMD(const VkShaderCorePropertiesFlagBitsAMD object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkIndirectStateFlagBitsNV(const VkIndirectStateFlagBitsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkIndirectCommandsLayoutUsageFlagBitsNV(const VkIndirectCommandsLayoutUsageFlagBitsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV"; + is_first = false; + } + if (object & VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NV"; + is_first = false; + } + if (object & VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NV"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkDeviceDiagnosticsConfigFlagBitsNV(const VkDeviceDiagnosticsConfigFlagBitsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV"; + is_first = false; + } + if (object & VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV"; + is_first = false; + } + if (object & VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV"; + is_first = false; + } + if (object & VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_ERROR_REPORTING_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_ERROR_REPORTING_BIT_NV"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkTileShadingRenderPassFlagBitsQCOM(const VkTileShadingRenderPassFlagBitsQCOM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_TILE_SHADING_RENDER_PASS_ENABLE_BIT_QCOM) { + settings.stream() << (is_first ? " (" : " | ") << "VK_TILE_SHADING_RENDER_PASS_ENABLE_BIT_QCOM"; + is_first = false; + } + if (object & VK_TILE_SHADING_RENDER_PASS_PER_TILE_EXECUTION_BIT_QCOM) { + settings.stream() << (is_first ? " (" : " | ") << "VK_TILE_SHADING_RENDER_PASS_PER_TILE_EXECUTION_BIT_QCOM"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} +#if defined(VK_USE_PLATFORM_METAL_EXT) + +template +void dump_VkExportMetalObjectTypeFlagBitsEXT(const VkExportMetalObjectTypeFlagBitsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_EXPORT_METAL_OBJECT_TYPE_METAL_DEVICE_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXPORT_METAL_OBJECT_TYPE_METAL_DEVICE_BIT_EXT"; + is_first = false; + } + if (object & VK_EXPORT_METAL_OBJECT_TYPE_METAL_COMMAND_QUEUE_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXPORT_METAL_OBJECT_TYPE_METAL_COMMAND_QUEUE_BIT_EXT"; + is_first = false; + } + if (object & VK_EXPORT_METAL_OBJECT_TYPE_METAL_BUFFER_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXPORT_METAL_OBJECT_TYPE_METAL_BUFFER_BIT_EXT"; + is_first = false; + } + if (object & VK_EXPORT_METAL_OBJECT_TYPE_METAL_TEXTURE_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXPORT_METAL_OBJECT_TYPE_METAL_TEXTURE_BIT_EXT"; + is_first = false; + } + if (object & VK_EXPORT_METAL_OBJECT_TYPE_METAL_IOSURFACE_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXPORT_METAL_OBJECT_TYPE_METAL_IOSURFACE_BIT_EXT"; + is_first = false; + } + if (object & VK_EXPORT_METAL_OBJECT_TYPE_METAL_SHARED_EVENT_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_EXPORT_METAL_OBJECT_TYPE_METAL_SHARED_EVENT_BIT_EXT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} +#endif // VK_USE_PLATFORM_METAL_EXT + +template +void dump_VkGraphicsPipelineLibraryFlagBitsEXT(const VkGraphicsPipelineLibraryFlagBitsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_GRAPHICS_PIPELINE_LIBRARY_VERTEX_INPUT_INTERFACE_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_GRAPHICS_PIPELINE_LIBRARY_VERTEX_INPUT_INTERFACE_BIT_EXT"; + is_first = false; + } + if (object & VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT"; + is_first = false; + } + if (object & VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT"; + is_first = false; + } + if (object & VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkImageCompressionFlagBitsEXT(const VkImageCompressionFlagBitsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object == VK_IMAGE_COMPRESSION_DEFAULT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_DEFAULT_EXT"; + is_first = false; + } + if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_DEFAULT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_DEFAULT_EXT"; + is_first = false; + } + if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_EXPLICIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_EXPLICIT_EXT"; + is_first = false; + } + if (object & VK_IMAGE_COMPRESSION_DISABLED_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_DISABLED_EXT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkImageCompressionFixedRateFlagBitsEXT(const VkImageCompressionFixedRateFlagBitsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object == VK_IMAGE_COMPRESSION_FIXED_RATE_NONE_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_NONE_EXT"; + is_first = false; + } + if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_1BPC_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_1BPC_BIT_EXT"; + is_first = false; + } + if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_2BPC_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_2BPC_BIT_EXT"; + is_first = false; + } + if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_3BPC_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_3BPC_BIT_EXT"; + is_first = false; + } + if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_4BPC_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_4BPC_BIT_EXT"; + is_first = false; + } + if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_5BPC_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_5BPC_BIT_EXT"; + is_first = false; + } + if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_6BPC_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_6BPC_BIT_EXT"; + is_first = false; + } + if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_7BPC_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_7BPC_BIT_EXT"; + is_first = false; + } + if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_8BPC_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_8BPC_BIT_EXT"; + is_first = false; + } + if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_9BPC_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_9BPC_BIT_EXT"; + is_first = false; + } + if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_10BPC_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_10BPC_BIT_EXT"; + is_first = false; + } + if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_11BPC_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_11BPC_BIT_EXT"; + is_first = false; + } + if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_12BPC_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_12BPC_BIT_EXT"; + is_first = false; + } + if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_13BPC_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_13BPC_BIT_EXT"; + is_first = false; + } + if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_14BPC_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_14BPC_BIT_EXT"; + is_first = false; + } + if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_15BPC_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_15BPC_BIT_EXT"; + is_first = false; + } + if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_16BPC_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_16BPC_BIT_EXT"; + is_first = false; + } + if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_17BPC_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_17BPC_BIT_EXT"; + is_first = false; + } + if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_18BPC_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_18BPC_BIT_EXT"; + is_first = false; + } + if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_19BPC_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_19BPC_BIT_EXT"; + is_first = false; + } + if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_20BPC_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_20BPC_BIT_EXT"; + is_first = false; + } + if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_21BPC_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_21BPC_BIT_EXT"; + is_first = false; + } + if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_22BPC_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_22BPC_BIT_EXT"; + is_first = false; + } + if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_23BPC_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_23BPC_BIT_EXT"; + is_first = false; + } + if (object & VK_IMAGE_COMPRESSION_FIXED_RATE_24BPC_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_COMPRESSION_FIXED_RATE_24BPC_BIT_EXT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkDeviceAddressBindingFlagBitsEXT(const VkDeviceAddressBindingFlagBitsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_DEVICE_ADDRESS_BINDING_INTERNAL_OBJECT_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DEVICE_ADDRESS_BINDING_INTERNAL_OBJECT_BIT_EXT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} +#if defined(VK_USE_PLATFORM_FUCHSIA) + +template +void dump_VkImageConstraintsInfoFlagBitsFUCHSIA(const VkImageConstraintsInfoFlagBitsFUCHSIA object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_RARELY_FUCHSIA) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_RARELY_FUCHSIA"; + is_first = false; + } + if (object & VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_OFTEN_FUCHSIA) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_OFTEN_FUCHSIA"; + is_first = false; + } + if (object & VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_RARELY_FUCHSIA) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_RARELY_FUCHSIA"; + is_first = false; + } + if (object & VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_OFTEN_FUCHSIA) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_OFTEN_FUCHSIA"; + is_first = false; + } + if (object & VK_IMAGE_CONSTRAINTS_INFO_PROTECTED_OPTIONAL_FUCHSIA) { + settings.stream() << (is_first ? " (" : " | ") << "VK_IMAGE_CONSTRAINTS_INFO_PROTECTED_OPTIONAL_FUCHSIA"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} +#endif // VK_USE_PLATFORM_FUCHSIA + +template +void dump_VkFrameBoundaryFlagBitsEXT(const VkFrameBoundaryFlagBitsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_FRAME_BOUNDARY_FRAME_END_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_FRAME_BOUNDARY_FRAME_END_BIT_EXT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkVideoEncodeRgbModelConversionFlagBitsVALVE(const VkVideoEncodeRgbModelConversionFlagBitsVALVE object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_RGB_IDENTITY_BIT_VALVE) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_RGB_IDENTITY_BIT_VALVE"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_IDENTITY_BIT_VALVE) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_IDENTITY_BIT_VALVE"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_709_BIT_VALVE) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_709_BIT_VALVE"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_601_BIT_VALVE) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_601_BIT_VALVE"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_2020_BIT_VALVE) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_2020_BIT_VALVE"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkVideoEncodeRgbRangeCompressionFlagBitsVALVE(const VkVideoEncodeRgbRangeCompressionFlagBitsVALVE object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_FULL_RANGE_BIT_VALVE) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_FULL_RANGE_BIT_VALVE"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_NARROW_RANGE_BIT_VALVE) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_NARROW_RANGE_BIT_VALVE"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkVideoEncodeRgbChromaOffsetFlagBitsVALVE(const VkVideoEncodeRgbChromaOffsetFlagBitsVALVE object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_COSITED_EVEN_BIT_VALVE) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_COSITED_EVEN_BIT_VALVE"; + is_first = false; + } + if (object & VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_MIDPOINT_BIT_VALVE) { + settings.stream() << (is_first ? " (" : " | ") << "VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_MIDPOINT_BIT_VALVE"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkBuildMicromapFlagBitsEXT(const VkBuildMicromapFlagBitsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_BUILD_MICROMAP_PREFER_FAST_TRACE_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_MICROMAP_PREFER_FAST_TRACE_BIT_EXT"; + is_first = false; + } + if (object & VK_BUILD_MICROMAP_PREFER_FAST_BUILD_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_MICROMAP_PREFER_FAST_BUILD_BIT_EXT"; + is_first = false; + } + if (object & VK_BUILD_MICROMAP_ALLOW_COMPACTION_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_BUILD_MICROMAP_ALLOW_COMPACTION_BIT_EXT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkMicromapCreateFlagBitsEXT(const VkMicromapCreateFlagBitsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_MICROMAP_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_MICROMAP_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkPhysicalDeviceSchedulingControlsFlagBitsARM(const VkPhysicalDeviceSchedulingControlsFlagBitsARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_SHADER_CORE_COUNT_ARM) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_SHADER_CORE_COUNT_ARM"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkMemoryDecompressionMethodFlagBitsEXT(const VkMemoryDecompressionMethodFlagBitsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_EXT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkTensorCreateFlagBitsARM(const VkTensorCreateFlagBitsARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_TENSOR_CREATE_MUTABLE_FORMAT_BIT_ARM) { + settings.stream() << (is_first ? " (" : " | ") << "VK_TENSOR_CREATE_MUTABLE_FORMAT_BIT_ARM"; + is_first = false; + } + if (object & VK_TENSOR_CREATE_PROTECTED_BIT_ARM) { + settings.stream() << (is_first ? " (" : " | ") << "VK_TENSOR_CREATE_PROTECTED_BIT_ARM"; + is_first = false; + } + if (object & VK_TENSOR_CREATE_DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_ARM) { + settings.stream() << (is_first ? " (" : " | ") << "VK_TENSOR_CREATE_DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_ARM"; + is_first = false; + } + if (object & VK_TENSOR_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM) { + settings.stream() << (is_first ? " (" : " | ") << "VK_TENSOR_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkTensorUsageFlagBitsARM(const VkTensorUsageFlagBitsARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_TENSOR_USAGE_SHADER_BIT_ARM) { + settings.stream() << (is_first ? " (" : " | ") << "VK_TENSOR_USAGE_SHADER_BIT_ARM"; + is_first = false; + } + if (object & VK_TENSOR_USAGE_TRANSFER_SRC_BIT_ARM) { + settings.stream() << (is_first ? " (" : " | ") << "VK_TENSOR_USAGE_TRANSFER_SRC_BIT_ARM"; + is_first = false; + } + if (object & VK_TENSOR_USAGE_TRANSFER_DST_BIT_ARM) { + settings.stream() << (is_first ? " (" : " | ") << "VK_TENSOR_USAGE_TRANSFER_DST_BIT_ARM"; + is_first = false; + } + if (object & VK_TENSOR_USAGE_IMAGE_ALIASING_BIT_ARM) { + settings.stream() << (is_first ? " (" : " | ") << "VK_TENSOR_USAGE_IMAGE_ALIASING_BIT_ARM"; + is_first = false; + } + if (object & VK_TENSOR_USAGE_DATA_GRAPH_BIT_ARM) { + settings.stream() << (is_first ? " (" : " | ") << "VK_TENSOR_USAGE_DATA_GRAPH_BIT_ARM"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkOpticalFlowGridSizeFlagBitsNV(const VkOpticalFlowGridSizeFlagBitsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object == VK_OPTICAL_FLOW_GRID_SIZE_UNKNOWN_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_GRID_SIZE_UNKNOWN_NV"; + is_first = false; + } + if (object & VK_OPTICAL_FLOW_GRID_SIZE_1X1_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_GRID_SIZE_1X1_BIT_NV"; + is_first = false; + } + if (object & VK_OPTICAL_FLOW_GRID_SIZE_2X2_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_GRID_SIZE_2X2_BIT_NV"; + is_first = false; + } + if (object & VK_OPTICAL_FLOW_GRID_SIZE_4X4_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_GRID_SIZE_4X4_BIT_NV"; + is_first = false; + } + if (object & VK_OPTICAL_FLOW_GRID_SIZE_8X8_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_GRID_SIZE_8X8_BIT_NV"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkOpticalFlowUsageFlagBitsNV(const VkOpticalFlowUsageFlagBitsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object == VK_OPTICAL_FLOW_USAGE_UNKNOWN_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_USAGE_UNKNOWN_NV"; + is_first = false; + } + if (object & VK_OPTICAL_FLOW_USAGE_INPUT_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_USAGE_INPUT_BIT_NV"; + is_first = false; + } + if (object & VK_OPTICAL_FLOW_USAGE_OUTPUT_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_USAGE_OUTPUT_BIT_NV"; + is_first = false; + } + if (object & VK_OPTICAL_FLOW_USAGE_HINT_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_USAGE_HINT_BIT_NV"; + is_first = false; + } + if (object & VK_OPTICAL_FLOW_USAGE_COST_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_USAGE_COST_BIT_NV"; + is_first = false; + } + if (object & VK_OPTICAL_FLOW_USAGE_GLOBAL_FLOW_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_USAGE_GLOBAL_FLOW_BIT_NV"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkOpticalFlowSessionCreateFlagBitsNV(const VkOpticalFlowSessionCreateFlagBitsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_HINT_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_HINT_BIT_NV"; + is_first = false; + } + if (object & VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_COST_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_COST_BIT_NV"; + is_first = false; + } + if (object & VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_GLOBAL_FLOW_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_GLOBAL_FLOW_BIT_NV"; + is_first = false; + } + if (object & VK_OPTICAL_FLOW_SESSION_CREATE_ALLOW_REGIONS_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_SESSION_CREATE_ALLOW_REGIONS_BIT_NV"; + is_first = false; + } + if (object & VK_OPTICAL_FLOW_SESSION_CREATE_BOTH_DIRECTIONS_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_SESSION_CREATE_BOTH_DIRECTIONS_BIT_NV"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkOpticalFlowExecuteFlagBitsNV(const VkOpticalFlowExecuteFlagBitsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_OPTICAL_FLOW_EXECUTE_DISABLE_TEMPORAL_HINTS_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_OPTICAL_FLOW_EXECUTE_DISABLE_TEMPORAL_HINTS_BIT_NV"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkShaderCreateFlagBitsEXT(const VkShaderCreateFlagBitsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_SHADER_CREATE_LINK_STAGE_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_CREATE_LINK_STAGE_BIT_EXT"; + is_first = false; + } + if (object & VK_SHADER_CREATE_DESCRIPTOR_HEAP_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_CREATE_DESCRIPTOR_HEAP_BIT_EXT"; + is_first = false; + } + if (object & VK_SHADER_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT"; + is_first = false; + } + if (object & VK_SHADER_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT"; + is_first = false; + } + if (object & VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT"; + is_first = false; + } + if (object & VK_SHADER_CREATE_DISPATCH_BASE_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_CREATE_DISPATCH_BASE_BIT_EXT"; + is_first = false; + } + if (object & VK_SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT"; + is_first = false; + } + if (object & VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT"; + is_first = false; + } + if (object & VK_SHADER_CREATE_INDIRECT_BINDABLE_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_CREATE_INDIRECT_BINDABLE_BIT_EXT"; + is_first = false; + } + if (object & VK_SHADER_CREATE_64_BIT_INDEXING_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_SHADER_CREATE_64_BIT_INDEXING_BIT_EXT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkDataGraphPipelineSessionCreateFlagBitsARM(const VkDataGraphPipelineSessionCreateFlagBitsARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_DATA_GRAPH_PIPELINE_SESSION_CREATE_PROTECTED_BIT_ARM) { + settings.stream() << (is_first ? " (" : " | ") << "VK_DATA_GRAPH_PIPELINE_SESSION_CREATE_PROTECTED_BIT_ARM"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkDataGraphPipelineDispatchFlagBitsARM(const VkDataGraphPipelineDispatchFlagBitsARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkClusterAccelerationStructureAddressResolutionFlagBitsNV(const VkClusterAccelerationStructureAddressResolutionFlagBitsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object == VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_NONE_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_NONE_NV"; + is_first = false; + } + if (object & VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_IMPLICIT_DATA_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_IMPLICIT_DATA_BIT_NV"; + is_first = false; + } + if (object & VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SCRATCH_DATA_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SCRATCH_DATA_BIT_NV"; + is_first = false; + } + if (object & VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_ADDRESS_ARRAY_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_ADDRESS_ARRAY_BIT_NV"; + is_first = false; + } + if (object & VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_SIZES_ARRAY_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_SIZES_ARRAY_BIT_NV"; + is_first = false; + } + if (object & VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SRC_INFOS_ARRAY_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SRC_INFOS_ARRAY_BIT_NV"; + is_first = false; + } + if (object & VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SRC_INFOS_COUNT_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SRC_INFOS_COUNT_BIT_NV"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkClusterAccelerationStructureClusterFlagBitsNV(const VkClusterAccelerationStructureClusterFlagBitsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_CLUSTER_ACCELERATION_STRUCTURE_CLUSTER_ALLOW_DISABLE_OPACITY_MICROMAPS_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_CLUSTER_ACCELERATION_STRUCTURE_CLUSTER_ALLOW_DISABLE_OPACITY_MICROMAPS_NV"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkClusterAccelerationStructureGeometryFlagBitsNV(const VkClusterAccelerationStructureGeometryFlagBitsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_CULL_DISABLE_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_CULL_DISABLE_BIT_NV"; + is_first = false; + } + if (object & VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_NO_DUPLICATE_ANYHIT_INVOCATION_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_NO_DUPLICATE_ANYHIT_INVOCATION_BIT_NV"; + is_first = false; + } + if (object & VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_OPAQUE_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_OPAQUE_BIT_NV"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkClusterAccelerationStructureIndexFormatFlagBitsNV(const VkClusterAccelerationStructureIndexFormatFlagBitsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_8BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_8BIT_NV"; + is_first = false; + } + if (object & VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_16BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_16BIT_NV"; + is_first = false; + } + if (object & VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_32BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_32BIT_NV"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkPartitionedAccelerationStructureInstanceFlagBitsNV(const VkPartitionedAccelerationStructureInstanceFlagBitsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_TRIANGLE_FACING_CULL_DISABLE_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_TRIANGLE_FACING_CULL_DISABLE_BIT_NV"; + is_first = false; + } + if (object & VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_TRIANGLE_FLIP_FACING_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_TRIANGLE_FLIP_FACING_BIT_NV"; + is_first = false; + } + if (object & VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_FORCE_OPAQUE_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_FORCE_OPAQUE_BIT_NV"; + is_first = false; + } + if (object & VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_FORCE_NO_OPAQUE_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_FORCE_NO_OPAQUE_BIT_NV"; + is_first = false; + } + if (object & VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_ENABLE_EXPLICIT_BOUNDING_BOX_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_ENABLE_EXPLICIT_BOUNDING_BOX_NV"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkIndirectCommandsInputModeFlagBitsEXT(const VkIndirectCommandsInputModeFlagBitsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_INDIRECT_COMMANDS_INPUT_MODE_VULKAN_INDEX_BUFFER_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_INDIRECT_COMMANDS_INPUT_MODE_VULKAN_INDEX_BUFFER_EXT"; + is_first = false; + } + if (object & VK_INDIRECT_COMMANDS_INPUT_MODE_DXGI_INDEX_BUFFER_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_INDIRECT_COMMANDS_INPUT_MODE_DXGI_INDEX_BUFFER_EXT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkIndirectCommandsLayoutUsageFlagBitsEXT(const VkIndirectCommandsLayoutUsageFlagBitsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_EXT"; + is_first = false; + } + if (object & VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_EXT"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_VkAccelerationStructureCreateFlagBitsKHR(const VkAccelerationStructureCreateFlagBitsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value_start(settings); + settings.stream() << object; + bool is_first = true; + if (object & VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR"; + is_first = false; + } + if (object & VK_ACCELERATION_STRUCTURE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCELERATION_STRUCTURE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT"; + is_first = false; + } + if (object & VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV) { + settings.stream() << (is_first ? " (" : " | ") << "VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV"; + is_first = false; + } + + if (!is_first) + settings.stream() << ")"; + dump_value_end(settings); + dump_end(settings, OutputConstruct::value, indents); +} + +//=========================== Flag Implementations ==========================// + +template +void dump_VkAccessFlags(const VkAccessFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkAccessFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkImageAspectFlags(const VkImageAspectFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkImageAspectFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkFormatFeatureFlags(const VkFormatFeatureFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkFormatFeatureFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkImageCreateFlags(const VkImageCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkImageCreateFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkSampleCountFlags(const VkSampleCountFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkSampleCountFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkImageUsageFlags(const VkImageUsageFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkImageUsageFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkInstanceCreateFlags(const VkInstanceCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkInstanceCreateFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkMemoryHeapFlags(const VkMemoryHeapFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkMemoryHeapFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkMemoryPropertyFlags(const VkMemoryPropertyFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkMemoryPropertyFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkQueueFlags(const VkQueueFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkQueueFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkDeviceCreateFlags(const VkDeviceCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkDeviceQueueCreateFlags(const VkDeviceQueueCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkDeviceQueueCreateFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkPipelineStageFlags(const VkPipelineStageFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkPipelineStageFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkMemoryMapFlags(const VkMemoryMapFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkMemoryMapFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkSparseMemoryBindFlags(const VkSparseMemoryBindFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkSparseMemoryBindFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkSparseImageFormatFlags(const VkSparseImageFormatFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkSparseImageFormatFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkFenceCreateFlags(const VkFenceCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkFenceCreateFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkSemaphoreCreateFlags(const VkSemaphoreCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkQueryPoolCreateFlags(const VkQueryPoolCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkQueryPoolCreateFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkQueryPipelineStatisticFlags(const VkQueryPipelineStatisticFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkQueryPipelineStatisticFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkQueryResultFlags(const VkQueryResultFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkQueryResultFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkBufferCreateFlags(const VkBufferCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkBufferCreateFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkBufferUsageFlags(const VkBufferUsageFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkBufferUsageFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkImageViewCreateFlags(const VkImageViewCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkImageViewCreateFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkDependencyFlags(const VkDependencyFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkDependencyFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkCommandPoolCreateFlags(const VkCommandPoolCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkCommandPoolCreateFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkCommandPoolResetFlags(const VkCommandPoolResetFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkCommandPoolResetFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkCommandBufferUsageFlags(const VkCommandBufferUsageFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkCommandBufferUsageFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkQueryControlFlags(const VkQueryControlFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkQueryControlFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkCommandBufferResetFlags(const VkCommandBufferResetFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkCommandBufferResetFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkEventCreateFlags(const VkEventCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkEventCreateFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkBufferViewCreateFlags(const VkBufferViewCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkShaderModuleCreateFlags(const VkShaderModuleCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkPipelineCacheCreateFlags(const VkPipelineCacheCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkPipelineCacheCreateFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkPipelineCreateFlags(const VkPipelineCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkPipelineCreateFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkPipelineShaderStageCreateFlags(const VkPipelineShaderStageCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkPipelineShaderStageCreateFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkPipelineLayoutCreateFlags(const VkPipelineLayoutCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkPipelineLayoutCreateFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkShaderStageFlags(const VkShaderStageFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkShaderStageFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkSamplerCreateFlags(const VkSamplerCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkSamplerCreateFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkDescriptorPoolCreateFlags(const VkDescriptorPoolCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkDescriptorPoolCreateFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkDescriptorPoolResetFlags(const VkDescriptorPoolResetFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkDescriptorSetLayoutCreateFlags(const VkDescriptorSetLayoutCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkDescriptorSetLayoutCreateFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkColorComponentFlags(const VkColorComponentFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkColorComponentFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkCullModeFlags(const VkCullModeFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkCullModeFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkPipelineVertexInputStateCreateFlags(const VkPipelineVertexInputStateCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkPipelineInputAssemblyStateCreateFlags(const VkPipelineInputAssemblyStateCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkPipelineTessellationStateCreateFlags(const VkPipelineTessellationStateCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkPipelineViewportStateCreateFlags(const VkPipelineViewportStateCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkPipelineRasterizationStateCreateFlags(const VkPipelineRasterizationStateCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkPipelineMultisampleStateCreateFlags(const VkPipelineMultisampleStateCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkPipelineDepthStencilStateCreateFlags(const VkPipelineDepthStencilStateCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkPipelineDepthStencilStateCreateFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkPipelineColorBlendStateCreateFlags(const VkPipelineColorBlendStateCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkPipelineColorBlendStateCreateFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkPipelineDynamicStateCreateFlags(const VkPipelineDynamicStateCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkAttachmentDescriptionFlags(const VkAttachmentDescriptionFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkAttachmentDescriptionFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkFramebufferCreateFlags(const VkFramebufferCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkFramebufferCreateFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkRenderPassCreateFlags(const VkRenderPassCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkRenderPassCreateFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkSubpassDescriptionFlags(const VkSubpassDescriptionFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkSubpassDescriptionFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkStencilFaceFlags(const VkStencilFaceFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkStencilFaceFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkPeerMemoryFeatureFlags(const VkPeerMemoryFeatureFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkPeerMemoryFeatureFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkMemoryAllocateFlags(const VkMemoryAllocateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkMemoryAllocateFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkCommandPoolTrimFlags(const VkCommandPoolTrimFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkExternalMemoryHandleTypeFlags(const VkExternalMemoryHandleTypeFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkExternalMemoryHandleTypeFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkExternalMemoryFeatureFlags(const VkExternalMemoryFeatureFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkExternalMemoryFeatureFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkExternalFenceHandleTypeFlags(const VkExternalFenceHandleTypeFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkExternalFenceHandleTypeFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkExternalFenceFeatureFlags(const VkExternalFenceFeatureFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkExternalFenceFeatureFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkFenceImportFlags(const VkFenceImportFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkFenceImportFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkSemaphoreImportFlags(const VkSemaphoreImportFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkSemaphoreImportFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkExternalSemaphoreHandleTypeFlags(const VkExternalSemaphoreHandleTypeFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkExternalSemaphoreHandleTypeFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkExternalSemaphoreFeatureFlags(const VkExternalSemaphoreFeatureFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkExternalSemaphoreFeatureFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkSubgroupFeatureFlags(const VkSubgroupFeatureFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkSubgroupFeatureFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkDescriptorUpdateTemplateCreateFlags(const VkDescriptorUpdateTemplateCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkResolveModeFlags(const VkResolveModeFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkResolveModeFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkSemaphoreWaitFlags(const VkSemaphoreWaitFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkSemaphoreWaitFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkDescriptorBindingFlags(const VkDescriptorBindingFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkDescriptorBindingFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkToolPurposeFlags(const VkToolPurposeFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkToolPurposeFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkPrivateDataSlotCreateFlags(const VkPrivateDataSlotCreateFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkPipelineStageFlags2(const VkPipelineStageFlags2 object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkPipelineStageFlagBits2(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkAccessFlags2(const VkAccessFlags2 object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkAccessFlagBits2(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkSubmitFlags(const VkSubmitFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkSubmitFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkFormatFeatureFlags2(const VkFormatFeatureFlags2 object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkFormatFeatureFlagBits2(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkPipelineCreationFeedbackFlags(const VkPipelineCreationFeedbackFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkPipelineCreationFeedbackFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkRenderingFlags(const VkRenderingFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkRenderingFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkMemoryUnmapFlags(const VkMemoryUnmapFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkMemoryUnmapFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkBufferUsageFlags2(const VkBufferUsageFlags2 object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkBufferUsageFlagBits2(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkHostImageCopyFlags(const VkHostImageCopyFlags object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkHostImageCopyFlagBits(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkPipelineCreateFlags2(const VkPipelineCreateFlags2 object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkPipelineCreateFlagBits2(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkCompositeAlphaFlagsKHR(const VkCompositeAlphaFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkCompositeAlphaFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkSurfaceTransformFlagsKHR(const VkSurfaceTransformFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkSurfaceTransformFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkSwapchainCreateFlagsKHR(const VkSwapchainCreateFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkSwapchainCreateFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkDeviceGroupPresentModeFlagsKHR(const VkDeviceGroupPresentModeFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkDeviceGroupPresentModeFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkDisplayModeCreateFlagsKHR(const VkDisplayModeCreateFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkDisplayPlaneAlphaFlagsKHR(const VkDisplayPlaneAlphaFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkDisplayPlaneAlphaFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkDisplaySurfaceCreateFlagsKHR(const VkDisplaySurfaceCreateFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +#if defined(VK_USE_PLATFORM_XLIB_KHR) +template +void dump_VkXlibSurfaceCreateFlagsKHR(const VkXlibSurfaceCreateFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +#endif // VK_USE_PLATFORM_XLIB_KHR +#if defined(VK_USE_PLATFORM_XCB_KHR) +template +void dump_VkXcbSurfaceCreateFlagsKHR(const VkXcbSurfaceCreateFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +#endif // VK_USE_PLATFORM_XCB_KHR +#if defined(VK_USE_PLATFORM_WAYLAND_KHR) +template +void dump_VkWaylandSurfaceCreateFlagsKHR(const VkWaylandSurfaceCreateFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +#endif // VK_USE_PLATFORM_WAYLAND_KHR +#if defined(VK_USE_PLATFORM_ANDROID_KHR) +template +void dump_VkAndroidSurfaceCreateFlagsKHR(const VkAndroidSurfaceCreateFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +#endif // VK_USE_PLATFORM_ANDROID_KHR +#if defined(VK_USE_PLATFORM_WIN32_KHR) +template +void dump_VkWin32SurfaceCreateFlagsKHR(const VkWin32SurfaceCreateFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +#endif // VK_USE_PLATFORM_WIN32_KHR +template +void dump_VkVideoCodecOperationFlagsKHR(const VkVideoCodecOperationFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkVideoCodecOperationFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkVideoChromaSubsamplingFlagsKHR(const VkVideoChromaSubsamplingFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkVideoChromaSubsamplingFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkVideoComponentBitDepthFlagsKHR(const VkVideoComponentBitDepthFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkVideoComponentBitDepthFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkVideoCapabilityFlagsKHR(const VkVideoCapabilityFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkVideoCapabilityFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkVideoSessionCreateFlagsKHR(const VkVideoSessionCreateFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkVideoSessionCreateFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkVideoSessionParametersCreateFlagsKHR(const VkVideoSessionParametersCreateFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkVideoSessionParametersCreateFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkVideoBeginCodingFlagsKHR(const VkVideoBeginCodingFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkVideoEndCodingFlagsKHR(const VkVideoEndCodingFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkVideoCodingControlFlagsKHR(const VkVideoCodingControlFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkVideoCodingControlFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkVideoDecodeCapabilityFlagsKHR(const VkVideoDecodeCapabilityFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkVideoDecodeCapabilityFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkVideoDecodeUsageFlagsKHR(const VkVideoDecodeUsageFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkVideoDecodeUsageFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkVideoDecodeFlagsKHR(const VkVideoDecodeFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkVideoEncodeH264CapabilityFlagsKHR(const VkVideoEncodeH264CapabilityFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkVideoEncodeH264CapabilityFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkVideoEncodeH264StdFlagsKHR(const VkVideoEncodeH264StdFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkVideoEncodeH264StdFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkVideoEncodeH264RateControlFlagsKHR(const VkVideoEncodeH264RateControlFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkVideoEncodeH264RateControlFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkVideoEncodeH265CapabilityFlagsKHR(const VkVideoEncodeH265CapabilityFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkVideoEncodeH265CapabilityFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkVideoEncodeH265StdFlagsKHR(const VkVideoEncodeH265StdFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkVideoEncodeH265StdFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkVideoEncodeH265CtbSizeFlagsKHR(const VkVideoEncodeH265CtbSizeFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkVideoEncodeH265CtbSizeFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkVideoEncodeH265TransformBlockSizeFlagsKHR(const VkVideoEncodeH265TransformBlockSizeFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkVideoEncodeH265TransformBlockSizeFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkVideoEncodeH265RateControlFlagsKHR(const VkVideoEncodeH265RateControlFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkVideoEncodeH265RateControlFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkVideoDecodeH264PictureLayoutFlagsKHR(const VkVideoDecodeH264PictureLayoutFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkVideoDecodeH264PictureLayoutFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkPerformanceCounterDescriptionFlagsKHR(const VkPerformanceCounterDescriptionFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkPerformanceCounterDescriptionFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkAcquireProfilingLockFlagsKHR(const VkAcquireProfilingLockFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkAcquireProfilingLockFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkVideoEncodeFlagsKHR(const VkVideoEncodeFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkVideoEncodeFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkVideoEncodeCapabilityFlagsKHR(const VkVideoEncodeCapabilityFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkVideoEncodeCapabilityFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkVideoEncodeRateControlModeFlagsKHR(const VkVideoEncodeRateControlModeFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkVideoEncodeRateControlModeFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkVideoEncodeFeedbackFlagsKHR(const VkVideoEncodeFeedbackFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkVideoEncodeFeedbackFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkVideoEncodeUsageFlagsKHR(const VkVideoEncodeUsageFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkVideoEncodeUsageFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkVideoEncodeContentFlagsKHR(const VkVideoEncodeContentFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkVideoEncodeContentFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkVideoEncodeRateControlFlagsKHR(const VkVideoEncodeRateControlFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkPresentScalingFlagsKHR(const VkPresentScalingFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkPresentScalingFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkPresentGravityFlagsKHR(const VkPresentGravityFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkPresentGravityFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkVideoEncodeAV1CapabilityFlagsKHR(const VkVideoEncodeAV1CapabilityFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkVideoEncodeAV1CapabilityFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkVideoEncodeAV1StdFlagsKHR(const VkVideoEncodeAV1StdFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkVideoEncodeAV1StdFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkVideoEncodeAV1SuperblockSizeFlagsKHR(const VkVideoEncodeAV1SuperblockSizeFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkVideoEncodeAV1SuperblockSizeFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkVideoEncodeAV1RateControlFlagsKHR(const VkVideoEncodeAV1RateControlFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkVideoEncodeAV1RateControlFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkAddressCopyFlagsKHR(const VkAddressCopyFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkAddressCopyFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkVideoEncodeIntraRefreshModeFlagsKHR(const VkVideoEncodeIntraRefreshModeFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkVideoEncodeIntraRefreshModeFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkAccessFlags3KHR(const VkAccessFlags3KHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkAccessFlagBits3KHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkRenderingAttachmentFlagsKHR(const VkRenderingAttachmentFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkRenderingAttachmentFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkResolveImageFlagsKHR(const VkResolveImageFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkResolveImageFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkDebugReportFlagsEXT(const VkDebugReportFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkDebugReportFlagBitsEXT(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkPipelineRasterizationStateStreamCreateFlagsEXT(const VkPipelineRasterizationStateStreamCreateFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +#if defined(VK_USE_PLATFORM_GGP) +template +void dump_VkStreamDescriptorSurfaceCreateFlagsGGP(const VkStreamDescriptorSurfaceCreateFlagsGGP object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +#endif // VK_USE_PLATFORM_GGP +template +void dump_VkExternalMemoryHandleTypeFlagsNV(const VkExternalMemoryHandleTypeFlagsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkExternalMemoryHandleTypeFlagBitsNV(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkExternalMemoryFeatureFlagsNV(const VkExternalMemoryFeatureFlagsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkExternalMemoryFeatureFlagBitsNV(static_cast(object), settings, type_name, var_name, indents, address); +} +#if defined(VK_USE_PLATFORM_VI_NN) +template +void dump_VkViSurfaceCreateFlagsNN(const VkViSurfaceCreateFlagsNN object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +#endif // VK_USE_PLATFORM_VI_NN +template +void dump_VkConditionalRenderingFlagsEXT(const VkConditionalRenderingFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkConditionalRenderingFlagBitsEXT(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkSurfaceCounterFlagsEXT(const VkSurfaceCounterFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkSurfaceCounterFlagBitsEXT(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkPipelineViewportSwizzleStateCreateFlagsNV(const VkPipelineViewportSwizzleStateCreateFlagsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkPipelineDiscardRectangleStateCreateFlagsEXT(const VkPipelineDiscardRectangleStateCreateFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkPipelineRasterizationConservativeStateCreateFlagsEXT(const VkPipelineRasterizationConservativeStateCreateFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkPipelineRasterizationDepthClipStateCreateFlagsEXT(const VkPipelineRasterizationDepthClipStateCreateFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +#if defined(VK_USE_PLATFORM_IOS_MVK) +template +void dump_VkIOSSurfaceCreateFlagsMVK(const VkIOSSurfaceCreateFlagsMVK object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +#endif // VK_USE_PLATFORM_IOS_MVK +#if defined(VK_USE_PLATFORM_MACOS_MVK) +template +void dump_VkMacOSSurfaceCreateFlagsMVK(const VkMacOSSurfaceCreateFlagsMVK object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +#endif // VK_USE_PLATFORM_MACOS_MVK +template +void dump_VkDebugUtilsMessengerCallbackDataFlagsEXT(const VkDebugUtilsMessengerCallbackDataFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkDebugUtilsMessageTypeFlagsEXT(const VkDebugUtilsMessageTypeFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkDebugUtilsMessageTypeFlagBitsEXT(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkDebugUtilsMessageSeverityFlagsEXT(const VkDebugUtilsMessageSeverityFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkDebugUtilsMessageSeverityFlagBitsEXT(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkDebugUtilsMessengerCreateFlagsEXT(const VkDebugUtilsMessengerCreateFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkTensorViewCreateFlagsARM(const VkTensorViewCreateFlagsARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkTensorViewCreateFlagBitsARM(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkSpirvResourceTypeFlagsEXT(const VkSpirvResourceTypeFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkSpirvResourceTypeFlagBitsEXT(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkPipelineCoverageToColorStateCreateFlagsNV(const VkPipelineCoverageToColorStateCreateFlagsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkPipelineCoverageModulationStateCreateFlagsNV(const VkPipelineCoverageModulationStateCreateFlagsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkValidationCacheCreateFlagsEXT(const VkValidationCacheCreateFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkGeometryFlagsKHR(const VkGeometryFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkGeometryFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkGeometryInstanceFlagsKHR(const VkGeometryInstanceFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkGeometryInstanceFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkBuildAccelerationStructureFlagsKHR(const VkBuildAccelerationStructureFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkBuildAccelerationStructureFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkPipelineCompilerControlFlagsAMD(const VkPipelineCompilerControlFlagsAMD object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkPipelineCompilerControlFlagBitsAMD(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkPresentStageFlagsEXT(const VkPresentStageFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkPresentStageFlagBitsEXT(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkPastPresentationTimingFlagsEXT(const VkPastPresentationTimingFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkPastPresentationTimingFlagBitsEXT(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkPresentTimingInfoFlagsEXT(const VkPresentTimingInfoFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkPresentTimingInfoFlagBitsEXT(static_cast(object), settings, type_name, var_name, indents, address); +} +#if defined(VK_USE_PLATFORM_FUCHSIA) +template +void dump_VkImagePipeSurfaceCreateFlagsFUCHSIA(const VkImagePipeSurfaceCreateFlagsFUCHSIA object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +#endif // VK_USE_PLATFORM_FUCHSIA +#if defined(VK_USE_PLATFORM_METAL_EXT) +template +void dump_VkMetalSurfaceCreateFlagsEXT(const VkMetalSurfaceCreateFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +#endif // VK_USE_PLATFORM_METAL_EXT +template +void dump_VkShaderCorePropertiesFlagsAMD(const VkShaderCorePropertiesFlagsAMD object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkShaderCorePropertiesFlagBitsAMD(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkPipelineCoverageReductionStateCreateFlagsNV(const VkPipelineCoverageReductionStateCreateFlagsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkHeadlessSurfaceCreateFlagsEXT(const VkHeadlessSurfaceCreateFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkIndirectStateFlagsNV(const VkIndirectStateFlagsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkIndirectStateFlagBitsNV(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkIndirectCommandsLayoutUsageFlagsNV(const VkIndirectCommandsLayoutUsageFlagsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkIndirectCommandsLayoutUsageFlagBitsNV(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkDeviceMemoryReportFlagsEXT(const VkDeviceMemoryReportFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkDeviceDiagnosticsConfigFlagsNV(const VkDeviceDiagnosticsConfigFlagsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkDeviceDiagnosticsConfigFlagBitsNV(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkTileShadingRenderPassFlagsQCOM(const VkTileShadingRenderPassFlagsQCOM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkTileShadingRenderPassFlagBitsQCOM(static_cast(object), settings, type_name, var_name, indents, address); +} +#if defined(VK_USE_PLATFORM_METAL_EXT) +template +void dump_VkExportMetalObjectTypeFlagsEXT(const VkExportMetalObjectTypeFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkExportMetalObjectTypeFlagBitsEXT(static_cast(object), settings, type_name, var_name, indents, address); +} +#endif // VK_USE_PLATFORM_METAL_EXT +template +void dump_VkGraphicsPipelineLibraryFlagsEXT(const VkGraphicsPipelineLibraryFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkGraphicsPipelineLibraryFlagBitsEXT(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkAccelerationStructureMotionInfoFlagsNV(const VkAccelerationStructureMotionInfoFlagsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkAccelerationStructureMotionInstanceFlagsNV(const VkAccelerationStructureMotionInstanceFlagsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkImageCompressionFlagsEXT(const VkImageCompressionFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkImageCompressionFlagBitsEXT(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkImageCompressionFixedRateFlagsEXT(const VkImageCompressionFixedRateFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkImageCompressionFixedRateFlagBitsEXT(static_cast(object), settings, type_name, var_name, indents, address); +} +#if defined(VK_USE_PLATFORM_DIRECTFB_EXT) +template +void dump_VkDirectFBSurfaceCreateFlagsEXT(const VkDirectFBSurfaceCreateFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +#endif // VK_USE_PLATFORM_DIRECTFB_EXT +template +void dump_VkDeviceAddressBindingFlagsEXT(const VkDeviceAddressBindingFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkDeviceAddressBindingFlagBitsEXT(static_cast(object), settings, type_name, var_name, indents, address); +} +#if defined(VK_USE_PLATFORM_FUCHSIA) +template +void dump_VkImageFormatConstraintsFlagsFUCHSIA(const VkImageFormatConstraintsFlagsFUCHSIA object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkImageConstraintsInfoFlagsFUCHSIA(const VkImageConstraintsInfoFlagsFUCHSIA object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkImageConstraintsInfoFlagBitsFUCHSIA(static_cast(object), settings, type_name, var_name, indents, address); +} +#endif // VK_USE_PLATFORM_FUCHSIA +template +void dump_VkFrameBoundaryFlagsEXT(const VkFrameBoundaryFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkFrameBoundaryFlagBitsEXT(static_cast(object), settings, type_name, var_name, indents, address); +} +#if defined(VK_USE_PLATFORM_SCREEN_QNX) +template +void dump_VkScreenSurfaceCreateFlagsQNX(const VkScreenSurfaceCreateFlagsQNX object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +#endif // VK_USE_PLATFORM_SCREEN_QNX +template +void dump_VkVideoEncodeRgbModelConversionFlagsVALVE(const VkVideoEncodeRgbModelConversionFlagsVALVE object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkVideoEncodeRgbModelConversionFlagBitsVALVE(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkVideoEncodeRgbRangeCompressionFlagsVALVE(const VkVideoEncodeRgbRangeCompressionFlagsVALVE object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkVideoEncodeRgbRangeCompressionFlagBitsVALVE(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkVideoEncodeRgbChromaOffsetFlagsVALVE(const VkVideoEncodeRgbChromaOffsetFlagsVALVE object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkVideoEncodeRgbChromaOffsetFlagBitsVALVE(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkBuildMicromapFlagsEXT(const VkBuildMicromapFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkBuildMicromapFlagBitsEXT(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkMicromapCreateFlagsEXT(const VkMicromapCreateFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkMicromapCreateFlagBitsEXT(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkPhysicalDeviceSchedulingControlsFlagsARM(const VkPhysicalDeviceSchedulingControlsFlagsARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkPhysicalDeviceSchedulingControlsFlagBitsARM(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkMemoryDecompressionMethodFlagsEXT(const VkMemoryDecompressionMethodFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkMemoryDecompressionMethodFlagBitsEXT(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkDirectDriverLoadingFlagsLUNARG(const VkDirectDriverLoadingFlagsLUNARG object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkTensorCreateFlagsARM(const VkTensorCreateFlagsARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkTensorCreateFlagBitsARM(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkTensorUsageFlagsARM(const VkTensorUsageFlagsARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkTensorUsageFlagBitsARM(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkOpticalFlowGridSizeFlagsNV(const VkOpticalFlowGridSizeFlagsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkOpticalFlowGridSizeFlagBitsNV(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkOpticalFlowUsageFlagsNV(const VkOpticalFlowUsageFlagsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkOpticalFlowUsageFlagBitsNV(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkOpticalFlowSessionCreateFlagsNV(const VkOpticalFlowSessionCreateFlagsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkOpticalFlowSessionCreateFlagBitsNV(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkOpticalFlowExecuteFlagsNV(const VkOpticalFlowExecuteFlagsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkOpticalFlowExecuteFlagBitsNV(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkShaderCreateFlagsEXT(const VkShaderCreateFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkShaderCreateFlagBitsEXT(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkDataGraphPipelineSessionCreateFlagsARM(const VkDataGraphPipelineSessionCreateFlagsARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkDataGraphPipelineSessionCreateFlagBitsARM(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkDataGraphPipelineDispatchFlagsARM(const VkDataGraphPipelineDispatchFlagsARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkDataGraphPipelineDispatchFlagBitsARM(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkClusterAccelerationStructureAddressResolutionFlagsNV(const VkClusterAccelerationStructureAddressResolutionFlagsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkClusterAccelerationStructureAddressResolutionFlagBitsNV(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkClusterAccelerationStructureClusterFlagsNV(const VkClusterAccelerationStructureClusterFlagsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkClusterAccelerationStructureClusterFlagBitsNV(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkClusterAccelerationStructureGeometryFlagsNV(const VkClusterAccelerationStructureGeometryFlagsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkClusterAccelerationStructureGeometryFlagBitsNV(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkClusterAccelerationStructureIndexFormatFlagsNV(const VkClusterAccelerationStructureIndexFormatFlagsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkClusterAccelerationStructureIndexFormatFlagBitsNV(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkPartitionedAccelerationStructureInstanceFlagsNV(const VkPartitionedAccelerationStructureInstanceFlagsNV object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkPartitionedAccelerationStructureInstanceFlagBitsNV(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkIndirectCommandsInputModeFlagsEXT(const VkIndirectCommandsInputModeFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkIndirectCommandsInputModeFlagBitsEXT(static_cast(object), settings, type_name, var_name, indents, address); +} +template +void dump_VkIndirectCommandsLayoutUsageFlagsEXT(const VkIndirectCommandsLayoutUsageFlagsEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkIndirectCommandsLayoutUsageFlagBitsEXT(static_cast(object), settings, type_name, var_name, indents, address); +} +#if defined(VK_USE_PLATFORM_OHOS) +template +void dump_VkSurfaceCreateFlagsOHOS(const VkSurfaceCreateFlagsOHOS object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +#endif // VK_USE_PLATFORM_OHOS +template +void dump_VkPerformanceCounterDescriptionFlagsARM(const VkPerformanceCounterDescriptionFlagsARM object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_value(settings, object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_VkAccelerationStructureCreateFlagsKHR(const VkAccelerationStructureCreateFlagsKHR object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_VkAccelerationStructureCreateFlagBitsKHR(static_cast(object), settings, type_name, var_name, indents, address); +} + +//======================= Func Pointer Implementations ======================// + +template +void dump_PFN_vkAllocationFunction(const PFN_vkAllocationFunction object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_address(settings, &object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_PFN_vkFreeFunction(const PFN_vkFreeFunction object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_address(settings, &object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_PFN_vkInternalAllocationNotification(const PFN_vkInternalAllocationNotification object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_address(settings, &object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_PFN_vkInternalFreeNotification(const PFN_vkInternalFreeNotification object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_address(settings, &object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_PFN_vkReallocationFunction(const PFN_vkReallocationFunction object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_address(settings, &object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_PFN_vkVoidFunction(const PFN_vkVoidFunction object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_address(settings, &object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_PFN_vkDebugReportCallbackEXT(const PFN_vkDebugReportCallbackEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_address(settings, &object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_PFN_vkDebugUtilsMessengerCallbackEXT(const PFN_vkDebugUtilsMessengerCallbackEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_address(settings, &object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_PFN_vkDeviceMemoryReportCallbackEXT(const PFN_vkDeviceMemoryReportCallbackEXT object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_address(settings, &object); + dump_end(settings, OutputConstruct::value, indents); +} +template +void dump_PFN_vkGetInstanceProcAddrLUNARG(const PFN_vkGetInstanceProcAddrLUNARG object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::value, type_name, var_name, indents, address); + dump_address(settings, &object); + dump_end(settings, OutputConstruct::value, indents); +} + +//=================== Video Struct and Union Implementations ==================// + +template +void dump_StdVideoH264SpsVuiFlags(const StdVideoH264SpsVuiFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.aspect_ratio_info_present_flag, settings, "uint32_t: 1", "aspect_ratio_info_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.overscan_info_present_flag, settings, "uint32_t: 1", "overscan_info_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.overscan_appropriate_flag, settings, "uint32_t: 1", "overscan_appropriate_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.video_signal_type_present_flag, settings, "uint32_t: 1", "video_signal_type_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.video_full_range_flag, settings, "uint32_t: 1", "video_full_range_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.color_description_present_flag, settings, "uint32_t: 1", "color_description_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.chroma_loc_info_present_flag, settings, "uint32_t: 1", "chroma_loc_info_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.timing_info_present_flag, settings, "uint32_t: 1", "timing_info_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.fixed_frame_rate_flag, settings, "uint32_t: 1", "fixed_frame_rate_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bitstream_restriction_flag, settings, "uint32_t: 1", "bitstream_restriction_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.nal_hrd_parameters_present_flag, settings, "uint32_t: 1", "nal_hrd_parameters_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vcl_hrd_parameters_present_flag, settings, "uint32_t: 1", "vcl_hrd_parameters_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoH264HrdParameters(const StdVideoH264HrdParameters& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.cpb_cnt_minus1, settings, "uint8_t", "cpb_cnt_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bit_rate_scale, settings, "uint8_t", "bit_rate_scale", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.cpb_size_scale, settings, "uint8_t", "cpb_size_scale", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved1, settings, "uint8_t", "reserved1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.bit_rate_value_minus1, STD_VIDEO_H264_CPB_CNT_LIST_SIZE, settings, "uint32_t[STD_VIDEO_H264_CPB_CNT_LIST_SIZE]", "bit_rate_value_minus1", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.cpb_size_value_minus1, STD_VIDEO_H264_CPB_CNT_LIST_SIZE, settings, "uint32_t[STD_VIDEO_H264_CPB_CNT_LIST_SIZE]", "cpb_size_value_minus1", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.cbr_flag, STD_VIDEO_H264_CPB_CNT_LIST_SIZE, settings, "uint8_t[STD_VIDEO_H264_CPB_CNT_LIST_SIZE]", "cbr_flag", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.initial_cpb_removal_delay_length_minus1, settings, "uint32_t", "initial_cpb_removal_delay_length_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.cpb_removal_delay_length_minus1, settings, "uint32_t", "cpb_removal_delay_length_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dpb_output_delay_length_minus1, settings, "uint32_t", "dpb_output_delay_length_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.time_offset_length, settings, "uint32_t", "time_offset_length", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoH264SequenceParameterSetVui(const StdVideoH264SequenceParameterSetVui& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_StdVideoH264SpsVuiFlags(object.flags, settings, "StdVideoH264SpsVuiFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoH264AspectRatioIdc(object.aspect_ratio_idc, settings, "StdVideoH264AspectRatioIdc", "aspect_ratio_idc", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sar_width, settings, "uint16_t", "sar_width", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sar_height, settings, "uint16_t", "sar_height", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.video_format, settings, "uint8_t", "video_format", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.colour_primaries, settings, "uint8_t", "colour_primaries", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.transfer_characteristics, settings, "uint8_t", "transfer_characteristics", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.matrix_coefficients, settings, "uint8_t", "matrix_coefficients", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.num_units_in_tick, settings, "uint32_t", "num_units_in_tick", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.time_scale, settings, "uint32_t", "time_scale", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.max_num_reorder_frames, settings, "uint8_t", "max_num_reorder_frames", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.max_dec_frame_buffering, settings, "uint8_t", "max_dec_frame_buffering", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.chroma_sample_loc_type_top_field, settings, "uint8_t", "chroma_sample_loc_type_top_field", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.chroma_sample_loc_type_bottom_field, settings, "uint8_t", "chroma_sample_loc_type_bottom_field", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved1, settings, "uint32_t", "reserved1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pHrdParameters, settings, "const StdVideoH264HrdParameters*", "pHrdParameters", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH264HrdParameters); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoH264SpsFlags(const StdVideoH264SpsFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.constraint_set0_flag, settings, "uint32_t: 1", "constraint_set0_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.constraint_set1_flag, settings, "uint32_t: 1", "constraint_set1_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.constraint_set2_flag, settings, "uint32_t: 1", "constraint_set2_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.constraint_set3_flag, settings, "uint32_t: 1", "constraint_set3_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.constraint_set4_flag, settings, "uint32_t: 1", "constraint_set4_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.constraint_set5_flag, settings, "uint32_t: 1", "constraint_set5_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.direct_8x8_inference_flag, settings, "uint32_t: 1", "direct_8x8_inference_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.mb_adaptive_frame_field_flag, settings, "uint32_t: 1", "mb_adaptive_frame_field_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.frame_mbs_only_flag, settings, "uint32_t: 1", "frame_mbs_only_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.delta_pic_order_always_zero_flag, settings, "uint32_t: 1", "delta_pic_order_always_zero_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.separate_colour_plane_flag, settings, "uint32_t: 1", "separate_colour_plane_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.gaps_in_frame_num_value_allowed_flag, settings, "uint32_t: 1", "gaps_in_frame_num_value_allowed_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.qpprime_y_zero_transform_bypass_flag, settings, "uint32_t: 1", "qpprime_y_zero_transform_bypass_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.frame_cropping_flag, settings, "uint32_t: 1", "frame_cropping_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.seq_scaling_matrix_present_flag, settings, "uint32_t: 1", "seq_scaling_matrix_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vui_parameters_present_flag, settings, "uint32_t: 1", "vui_parameters_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoH264ScalingLists(const StdVideoH264ScalingLists& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.scaling_list_present_mask, settings, "uint16_t", "scaling_list_present_mask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.use_default_scaling_matrix_mask, settings, "uint16_t", "use_default_scaling_matrix_mask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_double_array(object.ScalingList4x4, STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS, STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS, settings, "uint8_t[STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS][STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS]", "ScalingList4x4", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_double_array(object.ScalingList8x8, STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS, STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS, settings, "uint8_t[STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS][STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS]", "ScalingList8x8", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoH264SequenceParameterSet(const StdVideoH264SequenceParameterSet& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_StdVideoH264SpsFlags(object.flags, settings, "StdVideoH264SpsFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoH264ProfileIdc(object.profile_idc, settings, "StdVideoH264ProfileIdc", "profile_idc", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoH264LevelIdc(object.level_idc, settings, "StdVideoH264LevelIdc", "level_idc", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoH264ChromaFormatIdc(object.chroma_format_idc, settings, "StdVideoH264ChromaFormatIdc", "chroma_format_idc", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.seq_parameter_set_id, settings, "uint8_t", "seq_parameter_set_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bit_depth_luma_minus8, settings, "uint8_t", "bit_depth_luma_minus8", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bit_depth_chroma_minus8, settings, "uint8_t", "bit_depth_chroma_minus8", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.log2_max_frame_num_minus4, settings, "uint8_t", "log2_max_frame_num_minus4", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoH264PocType(object.pic_order_cnt_type, settings, "StdVideoH264PocType", "pic_order_cnt_type", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.offset_for_non_ref_pic, settings, "int32_t", "offset_for_non_ref_pic", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.offset_for_top_to_bottom_field, settings, "int32_t", "offset_for_top_to_bottom_field", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.log2_max_pic_order_cnt_lsb_minus4, settings, "uint8_t", "log2_max_pic_order_cnt_lsb_minus4", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.num_ref_frames_in_pic_order_cnt_cycle, settings, "uint8_t", "num_ref_frames_in_pic_order_cnt_cycle", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.max_num_ref_frames, settings, "uint8_t", "max_num_ref_frames", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved1, settings, "uint8_t", "reserved1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pic_width_in_mbs_minus1, settings, "uint32_t", "pic_width_in_mbs_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pic_height_in_map_units_minus1, settings, "uint32_t", "pic_height_in_map_units_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.frame_crop_left_offset, settings, "uint32_t", "frame_crop_left_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.frame_crop_right_offset, settings, "uint32_t", "frame_crop_right_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.frame_crop_top_offset, settings, "uint32_t", "frame_crop_top_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.frame_crop_bottom_offset, settings, "uint32_t", "frame_crop_bottom_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved2, settings, "uint32_t", "reserved2", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pOffsetForRefFrame, object.num_ref_frames_in_pic_order_cnt_cycle, settings, "const int32_t*", "pOffsetForRefFrame", "const int32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_pointer(object.pScalingLists, settings, "const StdVideoH264ScalingLists*", "pScalingLists", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH264ScalingLists); + dump_separate_members(settings); + dump_pointer(object.pSequenceParameterSetVui, settings, "const StdVideoH264SequenceParameterSetVui*", "pSequenceParameterSetVui", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH264SequenceParameterSetVui); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoH264PpsFlags(const StdVideoH264PpsFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.transform_8x8_mode_flag, settings, "uint32_t: 1", "transform_8x8_mode_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.redundant_pic_cnt_present_flag, settings, "uint32_t: 1", "redundant_pic_cnt_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.constrained_intra_pred_flag, settings, "uint32_t: 1", "constrained_intra_pred_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.deblocking_filter_control_present_flag, settings, "uint32_t: 1", "deblocking_filter_control_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.weighted_pred_flag, settings, "uint32_t: 1", "weighted_pred_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bottom_field_pic_order_in_frame_present_flag, settings, "uint32_t: 1", "bottom_field_pic_order_in_frame_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.entropy_coding_mode_flag, settings, "uint32_t: 1", "entropy_coding_mode_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pic_scaling_matrix_present_flag, settings, "uint32_t: 1", "pic_scaling_matrix_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoH264PictureParameterSet(const StdVideoH264PictureParameterSet& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_StdVideoH264PpsFlags(object.flags, settings, "StdVideoH264PpsFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.seq_parameter_set_id, settings, "uint8_t", "seq_parameter_set_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pic_parameter_set_id, settings, "uint8_t", "pic_parameter_set_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.num_ref_idx_l0_default_active_minus1, settings, "uint8_t", "num_ref_idx_l0_default_active_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.num_ref_idx_l1_default_active_minus1, settings, "uint8_t", "num_ref_idx_l1_default_active_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoH264WeightedBipredIdc(object.weighted_bipred_idc, settings, "StdVideoH264WeightedBipredIdc", "weighted_bipred_idc", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pic_init_qp_minus26, settings, "int8_t", "pic_init_qp_minus26", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pic_init_qs_minus26, settings, "int8_t", "pic_init_qs_minus26", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.chroma_qp_index_offset, settings, "int8_t", "chroma_qp_index_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.second_chroma_qp_index_offset, settings, "int8_t", "second_chroma_qp_index_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pScalingLists, settings, "const StdVideoH264ScalingLists*", "pScalingLists", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH264ScalingLists); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoDecodeH264PictureInfoFlags(const StdVideoDecodeH264PictureInfoFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.field_pic_flag, settings, "uint32_t: 1", "field_pic_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.is_intra, settings, "uint32_t: 1", "is_intra", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.IdrPicFlag, settings, "uint32_t: 1", "IdrPicFlag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bottom_field_flag, settings, "uint32_t: 1", "bottom_field_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.is_reference, settings, "uint32_t: 1", "is_reference", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.complementary_field_pair, settings, "uint32_t: 1", "complementary_field_pair", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoDecodeH264PictureInfo(const StdVideoDecodeH264PictureInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_StdVideoDecodeH264PictureInfoFlags(object.flags, settings, "StdVideoDecodeH264PictureInfoFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.seq_parameter_set_id, settings, "uint8_t", "seq_parameter_set_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pic_parameter_set_id, settings, "uint8_t", "pic_parameter_set_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved1, settings, "uint8_t", "reserved1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved2, settings, "uint8_t", "reserved2", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.frame_num, settings, "uint16_t", "frame_num", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.idr_pic_id, settings, "uint16_t", "idr_pic_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.PicOrderCnt, STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE, settings, "int32_t[STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE]", "PicOrderCnt", "int32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoDecodeH264ReferenceInfoFlags(const StdVideoDecodeH264ReferenceInfoFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.top_field_flag, settings, "uint32_t: 1", "top_field_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bottom_field_flag, settings, "uint32_t: 1", "bottom_field_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.used_for_long_term_reference, settings, "uint32_t: 1", "used_for_long_term_reference", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.is_non_existing, settings, "uint32_t: 1", "is_non_existing", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoDecodeH264ReferenceInfo(const StdVideoDecodeH264ReferenceInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_StdVideoDecodeH264ReferenceInfoFlags(object.flags, settings, "StdVideoDecodeH264ReferenceInfoFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.FrameNum, settings, "uint16_t", "FrameNum", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved, settings, "uint16_t", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.PicOrderCnt, STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE, settings, "int32_t[STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE]", "PicOrderCnt", "int32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoEncodeH264WeightTableFlags(const StdVideoEncodeH264WeightTableFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.luma_weight_l0_flag, settings, "uint32_t", "luma_weight_l0_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.chroma_weight_l0_flag, settings, "uint32_t", "chroma_weight_l0_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.luma_weight_l1_flag, settings, "uint32_t", "luma_weight_l1_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.chroma_weight_l1_flag, settings, "uint32_t", "chroma_weight_l1_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoEncodeH264WeightTable(const StdVideoEncodeH264WeightTable& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_StdVideoEncodeH264WeightTableFlags(object.flags, settings, "StdVideoEncodeH264WeightTableFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.luma_log2_weight_denom, settings, "uint8_t", "luma_log2_weight_denom", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.chroma_log2_weight_denom, settings, "uint8_t", "chroma_log2_weight_denom", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.luma_weight_l0, STD_VIDEO_H264_MAX_NUM_LIST_REF, settings, "int8_t[STD_VIDEO_H264_MAX_NUM_LIST_REF]", "luma_weight_l0", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.luma_offset_l0, STD_VIDEO_H264_MAX_NUM_LIST_REF, settings, "int8_t[STD_VIDEO_H264_MAX_NUM_LIST_REF]", "luma_offset_l0", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_double_array(object.chroma_weight_l0, STD_VIDEO_H264_MAX_NUM_LIST_REF, STD_VIDEO_H264_MAX_CHROMA_PLANES, settings, "int8_t[STD_VIDEO_H264_MAX_NUM_LIST_REF][STD_VIDEO_H264_MAX_CHROMA_PLANES]", "chroma_weight_l0", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_double_array(object.chroma_offset_l0, STD_VIDEO_H264_MAX_NUM_LIST_REF, STD_VIDEO_H264_MAX_CHROMA_PLANES, settings, "int8_t[STD_VIDEO_H264_MAX_NUM_LIST_REF][STD_VIDEO_H264_MAX_CHROMA_PLANES]", "chroma_offset_l0", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.luma_weight_l1, STD_VIDEO_H264_MAX_NUM_LIST_REF, settings, "int8_t[STD_VIDEO_H264_MAX_NUM_LIST_REF]", "luma_weight_l1", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.luma_offset_l1, STD_VIDEO_H264_MAX_NUM_LIST_REF, settings, "int8_t[STD_VIDEO_H264_MAX_NUM_LIST_REF]", "luma_offset_l1", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_double_array(object.chroma_weight_l1, STD_VIDEO_H264_MAX_NUM_LIST_REF, STD_VIDEO_H264_MAX_CHROMA_PLANES, settings, "int8_t[STD_VIDEO_H264_MAX_NUM_LIST_REF][STD_VIDEO_H264_MAX_CHROMA_PLANES]", "chroma_weight_l1", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_double_array(object.chroma_offset_l1, STD_VIDEO_H264_MAX_NUM_LIST_REF, STD_VIDEO_H264_MAX_CHROMA_PLANES, settings, "int8_t[STD_VIDEO_H264_MAX_NUM_LIST_REF][STD_VIDEO_H264_MAX_CHROMA_PLANES]", "chroma_offset_l1", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoEncodeH264SliceHeaderFlags(const StdVideoEncodeH264SliceHeaderFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.direct_spatial_mv_pred_flag, settings, "uint32_t: 1", "direct_spatial_mv_pred_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.num_ref_idx_active_override_flag, settings, "uint32_t: 1", "num_ref_idx_active_override_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved, settings, "uint32_t: 30", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoEncodeH264PictureInfoFlags(const StdVideoEncodeH264PictureInfoFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.IdrPicFlag, settings, "uint32_t: 1", "IdrPicFlag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.is_reference, settings, "uint32_t: 1", "is_reference", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.no_output_of_prior_pics_flag, settings, "uint32_t: 1", "no_output_of_prior_pics_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.long_term_reference_flag, settings, "uint32_t: 1", "long_term_reference_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.adaptive_ref_pic_marking_mode_flag, settings, "uint32_t: 1", "adaptive_ref_pic_marking_mode_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved, settings, "uint32_t: 27", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoEncodeH264ReferenceInfoFlags(const StdVideoEncodeH264ReferenceInfoFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.used_for_long_term_reference, settings, "uint32_t: 1", "used_for_long_term_reference", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved, settings, "uint32_t: 31", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoEncodeH264ReferenceListsInfoFlags(const StdVideoEncodeH264ReferenceListsInfoFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.ref_pic_list_modification_flag_l0, settings, "uint32_t: 1", "ref_pic_list_modification_flag_l0", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.ref_pic_list_modification_flag_l1, settings, "uint32_t: 1", "ref_pic_list_modification_flag_l1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved, settings, "uint32_t: 30", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoEncodeH264RefListModEntry(const StdVideoEncodeH264RefListModEntry& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_StdVideoH264ModificationOfPicNumsIdc(object.modification_of_pic_nums_idc, settings, "StdVideoH264ModificationOfPicNumsIdc", "modification_of_pic_nums_idc", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.abs_diff_pic_num_minus1, settings, "uint16_t", "abs_diff_pic_num_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.long_term_pic_num, settings, "uint16_t", "long_term_pic_num", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoEncodeH264RefPicMarkingEntry(const StdVideoEncodeH264RefPicMarkingEntry& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_StdVideoH264MemMgmtControlOp(object.memory_management_control_operation, settings, "StdVideoH264MemMgmtControlOp", "memory_management_control_operation", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.difference_of_pic_nums_minus1, settings, "uint16_t", "difference_of_pic_nums_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.long_term_pic_num, settings, "uint16_t", "long_term_pic_num", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.long_term_frame_idx, settings, "uint16_t", "long_term_frame_idx", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.max_long_term_frame_idx_plus1, settings, "uint16_t", "max_long_term_frame_idx_plus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoEncodeH264ReferenceListsInfo(const StdVideoEncodeH264ReferenceListsInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_StdVideoEncodeH264ReferenceListsInfoFlags(object.flags, settings, "StdVideoEncodeH264ReferenceListsInfoFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.num_ref_idx_l0_active_minus1, settings, "uint8_t", "num_ref_idx_l0_active_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.num_ref_idx_l1_active_minus1, settings, "uint8_t", "num_ref_idx_l1_active_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.RefPicList0, STD_VIDEO_H264_MAX_NUM_LIST_REF, settings, "uint8_t[STD_VIDEO_H264_MAX_NUM_LIST_REF]", "RefPicList0", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.RefPicList1, STD_VIDEO_H264_MAX_NUM_LIST_REF, settings, "uint8_t[STD_VIDEO_H264_MAX_NUM_LIST_REF]", "RefPicList1", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.refList0ModOpCount, settings, "uint8_t", "refList0ModOpCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.refList1ModOpCount, settings, "uint8_t", "refList1ModOpCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.refPicMarkingOpCount, settings, "uint8_t", "refPicMarkingOpCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.reserved1, 7, settings, "uint8_t[7]", "reserved1", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(object.pRefList0ModOperations, object.refList0ModOpCount, settings, "const StdVideoEncodeH264RefListModEntry*", "pRefList0ModOperations", "const StdVideoEncodeH264RefListModEntry", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeH264RefListModEntry); + dump_separate_members(settings); + dump_pointer_array(object.pRefList1ModOperations, object.refList1ModOpCount, settings, "const StdVideoEncodeH264RefListModEntry*", "pRefList1ModOperations", "const StdVideoEncodeH264RefListModEntry", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeH264RefListModEntry); + dump_separate_members(settings); + dump_pointer_array(object.pRefPicMarkingOperations, object.refPicMarkingOpCount, settings, "const StdVideoEncodeH264RefPicMarkingEntry*", "pRefPicMarkingOperations", "const StdVideoEncodeH264RefPicMarkingEntry", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeH264RefPicMarkingEntry); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoEncodeH264PictureInfo(const StdVideoEncodeH264PictureInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_StdVideoEncodeH264PictureInfoFlags(object.flags, settings, "StdVideoEncodeH264PictureInfoFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.seq_parameter_set_id, settings, "uint8_t", "seq_parameter_set_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pic_parameter_set_id, settings, "uint8_t", "pic_parameter_set_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.idr_pic_id, settings, "uint16_t", "idr_pic_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoH264PictureType(object.primary_pic_type, settings, "StdVideoH264PictureType", "primary_pic_type", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.frame_num, settings, "uint32_t", "frame_num", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.PicOrderCnt, settings, "int32_t", "PicOrderCnt", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.temporal_id, settings, "uint8_t", "temporal_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.reserved1, 3, settings, "uint8_t[3]", "reserved1", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_pointer(object.pRefLists, settings, "const StdVideoEncodeH264ReferenceListsInfo*", "pRefLists", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeH264ReferenceListsInfo); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoEncodeH264ReferenceInfo(const StdVideoEncodeH264ReferenceInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_StdVideoEncodeH264ReferenceInfoFlags(object.flags, settings, "StdVideoEncodeH264ReferenceInfoFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoH264PictureType(object.primary_pic_type, settings, "StdVideoH264PictureType", "primary_pic_type", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.FrameNum, settings, "uint32_t", "FrameNum", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.PicOrderCnt, settings, "int32_t", "PicOrderCnt", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.long_term_pic_num, settings, "uint16_t", "long_term_pic_num", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.long_term_frame_idx, settings, "uint16_t", "long_term_frame_idx", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.temporal_id, settings, "uint8_t", "temporal_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoEncodeH264SliceHeader(const StdVideoEncodeH264SliceHeader& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_StdVideoEncodeH264SliceHeaderFlags(object.flags, settings, "StdVideoEncodeH264SliceHeaderFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.first_mb_in_slice, settings, "uint32_t", "first_mb_in_slice", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoH264SliceType(object.slice_type, settings, "StdVideoH264SliceType", "slice_type", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.slice_alpha_c0_offset_div2, settings, "int8_t", "slice_alpha_c0_offset_div2", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.slice_beta_offset_div2, settings, "int8_t", "slice_beta_offset_div2", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.slice_qp_delta, settings, "int8_t", "slice_qp_delta", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved1, settings, "uint8_t", "reserved1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoH264CabacInitIdc(object.cabac_init_idc, settings, "StdVideoH264CabacInitIdc", "cabac_init_idc", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoH264DisableDeblockingFilterIdc(object.disable_deblocking_filter_idc, settings, "StdVideoH264DisableDeblockingFilterIdc", "disable_deblocking_filter_idc", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pWeightTable, settings, "const StdVideoEncodeH264WeightTable*", "pWeightTable", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeH264WeightTable); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoH265DecPicBufMgr(const StdVideoH265DecPicBufMgr& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_single_array(object.max_latency_increase_plus1, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE, settings, "uint32_t[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE]", "max_latency_increase_plus1", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.max_dec_pic_buffering_minus1, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE, settings, "uint8_t[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE]", "max_dec_pic_buffering_minus1", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.max_num_reorder_pics, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE, settings, "uint8_t[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE]", "max_num_reorder_pics", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoH265SubLayerHrdParameters(const StdVideoH265SubLayerHrdParameters& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_single_array(object.bit_rate_value_minus1, STD_VIDEO_H265_CPB_CNT_LIST_SIZE, settings, "uint32_t[STD_VIDEO_H265_CPB_CNT_LIST_SIZE]", "bit_rate_value_minus1", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.cpb_size_value_minus1, STD_VIDEO_H265_CPB_CNT_LIST_SIZE, settings, "uint32_t[STD_VIDEO_H265_CPB_CNT_LIST_SIZE]", "cpb_size_value_minus1", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.cpb_size_du_value_minus1, STD_VIDEO_H265_CPB_CNT_LIST_SIZE, settings, "uint32_t[STD_VIDEO_H265_CPB_CNT_LIST_SIZE]", "cpb_size_du_value_minus1", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.bit_rate_du_value_minus1, STD_VIDEO_H265_CPB_CNT_LIST_SIZE, settings, "uint32_t[STD_VIDEO_H265_CPB_CNT_LIST_SIZE]", "bit_rate_du_value_minus1", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.cbr_flag, settings, "uint32_t", "cbr_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoH265HrdFlags(const StdVideoH265HrdFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.nal_hrd_parameters_present_flag, settings, "uint32_t: 1", "nal_hrd_parameters_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vcl_hrd_parameters_present_flag, settings, "uint32_t: 1", "vcl_hrd_parameters_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sub_pic_hrd_params_present_flag, settings, "uint32_t: 1", "sub_pic_hrd_params_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sub_pic_cpb_params_in_pic_timing_sei_flag, settings, "uint32_t: 1", "sub_pic_cpb_params_in_pic_timing_sei_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.fixed_pic_rate_general_flag, settings, "uint32_t: 8", "fixed_pic_rate_general_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.fixed_pic_rate_within_cvs_flag, settings, "uint32_t: 8", "fixed_pic_rate_within_cvs_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.low_delay_hrd_flag, settings, "uint32_t: 8", "low_delay_hrd_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoH265HrdParameters(const StdVideoH265HrdParameters& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_StdVideoH265HrdFlags(object.flags, settings, "StdVideoH265HrdFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tick_divisor_minus2, settings, "uint8_t", "tick_divisor_minus2", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.du_cpb_removal_delay_increment_length_minus1, settings, "uint8_t", "du_cpb_removal_delay_increment_length_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dpb_output_delay_du_length_minus1, settings, "uint8_t", "dpb_output_delay_du_length_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bit_rate_scale, settings, "uint8_t", "bit_rate_scale", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.cpb_size_scale, settings, "uint8_t", "cpb_size_scale", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.cpb_size_du_scale, settings, "uint8_t", "cpb_size_du_scale", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.initial_cpb_removal_delay_length_minus1, settings, "uint8_t", "initial_cpb_removal_delay_length_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.au_cpb_removal_delay_length_minus1, settings, "uint8_t", "au_cpb_removal_delay_length_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dpb_output_delay_length_minus1, settings, "uint8_t", "dpb_output_delay_length_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.cpb_cnt_minus1, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE, settings, "uint8_t[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE]", "cpb_cnt_minus1", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.elemental_duration_in_tc_minus1, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE, settings, "uint16_t[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE]", "elemental_duration_in_tc_minus1", "uint16_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.reserved, 3, settings, "uint16_t[3]", "reserved", "uint16_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + if (object.flags.nal_hrd_parameters_present_flag == 1) { + dump_pointer_array(object.pSubLayerHrdParametersNal, ApiDumpInstance::current().getIsInVps() ? ApiDumpInstance::current().getVpsMaxSubLayersMinus1() : ApiDumpInstance::current().getSpsMaxSubLayersMinus1(), settings, "const StdVideoH265SubLayerHrdParameters*", "pSubLayerHrdParametersNal", "const StdVideoH265SubLayerHrdParameters", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265SubLayerHrdParameters); + } else { + if constexpr (Format == ApiDumpFormat::Text || Format == ApiDumpFormat::Html) { + dump_special("UNUSED", settings, "const StdVideoH265SubLayerHrdParameters*", "pSubLayerHrdParametersNal", indents + 1); + } else if constexpr (Format == ApiDumpFormat::Json) { + dump_json_UNUSED(settings, "const StdVideoH265SubLayerHrdParameters*", "pSubLayerHrdParametersNal", indents + 2); + } + } + dump_separate_members(settings); + if (object.flags.vcl_hrd_parameters_present_flag == 1) { + dump_pointer_array(object.pSubLayerHrdParametersVcl, ApiDumpInstance::current().getIsInVps() ? ApiDumpInstance::current().getVpsMaxSubLayersMinus1() : ApiDumpInstance::current().getSpsMaxSubLayersMinus1(), settings, "const StdVideoH265SubLayerHrdParameters*", "pSubLayerHrdParametersVcl", "const StdVideoH265SubLayerHrdParameters", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265SubLayerHrdParameters); + } else { + if constexpr (Format == ApiDumpFormat::Text || Format == ApiDumpFormat::Html) { + dump_special("UNUSED", settings, "const StdVideoH265SubLayerHrdParameters*", "pSubLayerHrdParametersVcl", indents + 1); + } else if constexpr (Format == ApiDumpFormat::Json) { + dump_json_UNUSED(settings, "const StdVideoH265SubLayerHrdParameters*", "pSubLayerHrdParametersVcl", indents + 2); + } + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoH265VpsFlags(const StdVideoH265VpsFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.vps_temporal_id_nesting_flag, settings, "uint32_t: 1", "vps_temporal_id_nesting_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vps_sub_layer_ordering_info_present_flag, settings, "uint32_t: 1", "vps_sub_layer_ordering_info_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vps_timing_info_present_flag, settings, "uint32_t: 1", "vps_timing_info_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vps_poc_proportional_to_timing_flag, settings, "uint32_t: 1", "vps_poc_proportional_to_timing_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoH265ProfileTierLevelFlags(const StdVideoH265ProfileTierLevelFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.general_tier_flag, settings, "uint32_t: 1", "general_tier_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.general_progressive_source_flag, settings, "uint32_t: 1", "general_progressive_source_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.general_interlaced_source_flag, settings, "uint32_t: 1", "general_interlaced_source_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.general_non_packed_constraint_flag, settings, "uint32_t: 1", "general_non_packed_constraint_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.general_frame_only_constraint_flag, settings, "uint32_t: 1", "general_frame_only_constraint_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoH265ProfileTierLevel(const StdVideoH265ProfileTierLevel& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_StdVideoH265ProfileTierLevelFlags(object.flags, settings, "StdVideoH265ProfileTierLevelFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoH265ProfileIdc(object.general_profile_idc, settings, "StdVideoH265ProfileIdc", "general_profile_idc", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoH265LevelIdc(object.general_level_idc, settings, "StdVideoH265LevelIdc", "general_level_idc", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoH265VideoParameterSet(const StdVideoH265VideoParameterSet& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + ApiDumpInstance::current().setVpsMaxSubLayersMinus1(object.vps_max_sub_layers_minus1); + ApiDumpInstance::current().setIsInVps(true); + dump_StdVideoH265VpsFlags(object.flags, settings, "StdVideoH265VpsFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vps_video_parameter_set_id, settings, "uint8_t", "vps_video_parameter_set_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vps_max_sub_layers_minus1, settings, "uint8_t", "vps_max_sub_layers_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved1, settings, "uint8_t", "reserved1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved2, settings, "uint8_t", "reserved2", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vps_num_units_in_tick, settings, "uint32_t", "vps_num_units_in_tick", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vps_time_scale, settings, "uint32_t", "vps_time_scale", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vps_num_ticks_poc_diff_one_minus1, settings, "uint32_t", "vps_num_ticks_poc_diff_one_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved3, settings, "uint32_t", "reserved3", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pDecPicBufMgr, settings, "const StdVideoH265DecPicBufMgr*", "pDecPicBufMgr", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265DecPicBufMgr); + dump_separate_members(settings); + dump_pointer(object.pHrdParameters, settings, "const StdVideoH265HrdParameters*", "pHrdParameters", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265HrdParameters); + dump_separate_members(settings); + dump_pointer(object.pProfileTierLevel, settings, "const StdVideoH265ProfileTierLevel*", "pProfileTierLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265ProfileTierLevel); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoH265ScalingLists(const StdVideoH265ScalingLists& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_double_array(object.ScalingList4x4, STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS, STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS, settings, "uint8_t[STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS]", "ScalingList4x4", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_double_array(object.ScalingList8x8, STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS, STD_VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS, settings, "uint8_t[STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS]", "ScalingList8x8", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_double_array(object.ScalingList16x16, STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS, STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS, settings, "uint8_t[STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS]", "ScalingList16x16", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_double_array(object.ScalingList32x32, STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS, STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS, settings, "uint8_t[STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS]", "ScalingList32x32", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.ScalingListDCCoef16x16, STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS, settings, "uint8_t[STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS]", "ScalingListDCCoef16x16", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.ScalingListDCCoef32x32, STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS, settings, "uint8_t[STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS]", "ScalingListDCCoef32x32", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoH265SpsVuiFlags(const StdVideoH265SpsVuiFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.aspect_ratio_info_present_flag, settings, "uint32_t: 1", "aspect_ratio_info_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.overscan_info_present_flag, settings, "uint32_t: 1", "overscan_info_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.overscan_appropriate_flag, settings, "uint32_t: 1", "overscan_appropriate_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.video_signal_type_present_flag, settings, "uint32_t: 1", "video_signal_type_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.video_full_range_flag, settings, "uint32_t: 1", "video_full_range_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.colour_description_present_flag, settings, "uint32_t: 1", "colour_description_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.chroma_loc_info_present_flag, settings, "uint32_t: 1", "chroma_loc_info_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.neutral_chroma_indication_flag, settings, "uint32_t: 1", "neutral_chroma_indication_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.field_seq_flag, settings, "uint32_t: 1", "field_seq_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.frame_field_info_present_flag, settings, "uint32_t: 1", "frame_field_info_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.default_display_window_flag, settings, "uint32_t: 1", "default_display_window_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vui_timing_info_present_flag, settings, "uint32_t: 1", "vui_timing_info_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vui_poc_proportional_to_timing_flag, settings, "uint32_t: 1", "vui_poc_proportional_to_timing_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vui_hrd_parameters_present_flag, settings, "uint32_t: 1", "vui_hrd_parameters_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bitstream_restriction_flag, settings, "uint32_t: 1", "bitstream_restriction_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tiles_fixed_structure_flag, settings, "uint32_t: 1", "tiles_fixed_structure_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.motion_vectors_over_pic_boundaries_flag, settings, "uint32_t: 1", "motion_vectors_over_pic_boundaries_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.restricted_ref_pic_lists_flag, settings, "uint32_t: 1", "restricted_ref_pic_lists_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoH265SequenceParameterSetVui(const StdVideoH265SequenceParameterSetVui& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_StdVideoH265SpsVuiFlags(object.flags, settings, "StdVideoH265SpsVuiFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoH265AspectRatioIdc(object.aspect_ratio_idc, settings, "StdVideoH265AspectRatioIdc", "aspect_ratio_idc", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sar_width, settings, "uint16_t", "sar_width", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sar_height, settings, "uint16_t", "sar_height", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.video_format, settings, "uint8_t", "video_format", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.colour_primaries, settings, "uint8_t", "colour_primaries", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.transfer_characteristics, settings, "uint8_t", "transfer_characteristics", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.matrix_coeffs, settings, "uint8_t", "matrix_coeffs", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.chroma_sample_loc_type_top_field, settings, "uint8_t", "chroma_sample_loc_type_top_field", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.chroma_sample_loc_type_bottom_field, settings, "uint8_t", "chroma_sample_loc_type_bottom_field", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved1, settings, "uint8_t", "reserved1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved2, settings, "uint8_t", "reserved2", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.def_disp_win_left_offset, settings, "uint16_t", "def_disp_win_left_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.def_disp_win_right_offset, settings, "uint16_t", "def_disp_win_right_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.def_disp_win_top_offset, settings, "uint16_t", "def_disp_win_top_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.def_disp_win_bottom_offset, settings, "uint16_t", "def_disp_win_bottom_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vui_num_units_in_tick, settings, "uint32_t", "vui_num_units_in_tick", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vui_time_scale, settings, "uint32_t", "vui_time_scale", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vui_num_ticks_poc_diff_one_minus1, settings, "uint32_t", "vui_num_ticks_poc_diff_one_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.min_spatial_segmentation_idc, settings, "uint16_t", "min_spatial_segmentation_idc", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved3, settings, "uint16_t", "reserved3", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.max_bytes_per_pic_denom, settings, "uint8_t", "max_bytes_per_pic_denom", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.max_bits_per_min_cu_denom, settings, "uint8_t", "max_bits_per_min_cu_denom", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.log2_max_mv_length_horizontal, settings, "uint8_t", "log2_max_mv_length_horizontal", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.log2_max_mv_length_vertical, settings, "uint8_t", "log2_max_mv_length_vertical", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pHrdParameters, settings, "const StdVideoH265HrdParameters*", "pHrdParameters", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265HrdParameters); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoH265PredictorPaletteEntries(const StdVideoH265PredictorPaletteEntries& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_double_array(object.PredictorPaletteEntries, STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE, STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE, settings, "uint16_t[STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE][STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE]", "PredictorPaletteEntries", "uint16_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoH265SpsFlags(const StdVideoH265SpsFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.sps_temporal_id_nesting_flag, settings, "uint32_t: 1", "sps_temporal_id_nesting_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.separate_colour_plane_flag, settings, "uint32_t: 1", "separate_colour_plane_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.conformance_window_flag, settings, "uint32_t: 1", "conformance_window_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sps_sub_layer_ordering_info_present_flag, settings, "uint32_t: 1", "sps_sub_layer_ordering_info_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.scaling_list_enabled_flag, settings, "uint32_t: 1", "scaling_list_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sps_scaling_list_data_present_flag, settings, "uint32_t: 1", "sps_scaling_list_data_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.amp_enabled_flag, settings, "uint32_t: 1", "amp_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sample_adaptive_offset_enabled_flag, settings, "uint32_t: 1", "sample_adaptive_offset_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pcm_enabled_flag, settings, "uint32_t: 1", "pcm_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pcm_loop_filter_disabled_flag, settings, "uint32_t: 1", "pcm_loop_filter_disabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.long_term_ref_pics_present_flag, settings, "uint32_t: 1", "long_term_ref_pics_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sps_temporal_mvp_enabled_flag, settings, "uint32_t: 1", "sps_temporal_mvp_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.strong_intra_smoothing_enabled_flag, settings, "uint32_t: 1", "strong_intra_smoothing_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vui_parameters_present_flag, settings, "uint32_t: 1", "vui_parameters_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sps_extension_present_flag, settings, "uint32_t: 1", "sps_extension_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sps_range_extension_flag, settings, "uint32_t: 1", "sps_range_extension_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.transform_skip_rotation_enabled_flag, settings, "uint32_t: 1", "transform_skip_rotation_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.transform_skip_context_enabled_flag, settings, "uint32_t: 1", "transform_skip_context_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.implicit_rdpcm_enabled_flag, settings, "uint32_t: 1", "implicit_rdpcm_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.explicit_rdpcm_enabled_flag, settings, "uint32_t: 1", "explicit_rdpcm_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.extended_precision_processing_flag, settings, "uint32_t: 1", "extended_precision_processing_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.intra_smoothing_disabled_flag, settings, "uint32_t: 1", "intra_smoothing_disabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.high_precision_offsets_enabled_flag, settings, "uint32_t: 1", "high_precision_offsets_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.persistent_rice_adaptation_enabled_flag, settings, "uint32_t: 1", "persistent_rice_adaptation_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.cabac_bypass_alignment_enabled_flag, settings, "uint32_t: 1", "cabac_bypass_alignment_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sps_scc_extension_flag, settings, "uint32_t: 1", "sps_scc_extension_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sps_curr_pic_ref_enabled_flag, settings, "uint32_t: 1", "sps_curr_pic_ref_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.palette_mode_enabled_flag, settings, "uint32_t: 1", "palette_mode_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sps_palette_predictor_initializers_present_flag, settings, "uint32_t: 1", "sps_palette_predictor_initializers_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.intra_boundary_filtering_disabled_flag, settings, "uint32_t: 1", "intra_boundary_filtering_disabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoH265ShortTermRefPicSetFlags(const StdVideoH265ShortTermRefPicSetFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.inter_ref_pic_set_prediction_flag, settings, "uint32_t: 1", "inter_ref_pic_set_prediction_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.delta_rps_sign, settings, "uint32_t: 1", "delta_rps_sign", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoH265ShortTermRefPicSet(const StdVideoH265ShortTermRefPicSet& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_StdVideoH265ShortTermRefPicSetFlags(object.flags, settings, "StdVideoH265ShortTermRefPicSetFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.delta_idx_minus1, settings, "uint32_t", "delta_idx_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.use_delta_flag, settings, "uint16_t", "use_delta_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.abs_delta_rps_minus1, settings, "uint16_t", "abs_delta_rps_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.used_by_curr_pic_flag, settings, "uint16_t", "used_by_curr_pic_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.used_by_curr_pic_s0_flag, settings, "uint16_t", "used_by_curr_pic_s0_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.used_by_curr_pic_s1_flag, settings, "uint16_t", "used_by_curr_pic_s1_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved1, settings, "uint16_t", "reserved1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved2, settings, "uint8_t", "reserved2", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved3, settings, "uint8_t", "reserved3", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.num_negative_pics, settings, "uint8_t", "num_negative_pics", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.num_positive_pics, settings, "uint8_t", "num_positive_pics", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.delta_poc_s0_minus1, STD_VIDEO_H265_MAX_DPB_SIZE, settings, "uint16_t[STD_VIDEO_H265_MAX_DPB_SIZE]", "delta_poc_s0_minus1", "uint16_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.delta_poc_s1_minus1, STD_VIDEO_H265_MAX_DPB_SIZE, settings, "uint16_t[STD_VIDEO_H265_MAX_DPB_SIZE]", "delta_poc_s1_minus1", "uint16_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoH265LongTermRefPicsSps(const StdVideoH265LongTermRefPicsSps& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.used_by_curr_pic_lt_sps_flag, settings, "uint32_t", "used_by_curr_pic_lt_sps_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.lt_ref_pic_poc_lsb_sps, STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS, settings, "uint32_t[STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS]", "lt_ref_pic_poc_lsb_sps", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoH265SequenceParameterSet(const StdVideoH265SequenceParameterSet& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + ApiDumpInstance::current().setSpsMaxSubLayersMinus1(object.sps_max_sub_layers_minus1); + ApiDumpInstance::current().setIsInVps(false); + dump_StdVideoH265SpsFlags(object.flags, settings, "StdVideoH265SpsFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoH265ChromaFormatIdc(object.chroma_format_idc, settings, "StdVideoH265ChromaFormatIdc", "chroma_format_idc", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pic_width_in_luma_samples, settings, "uint32_t", "pic_width_in_luma_samples", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pic_height_in_luma_samples, settings, "uint32_t", "pic_height_in_luma_samples", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sps_video_parameter_set_id, settings, "uint8_t", "sps_video_parameter_set_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sps_max_sub_layers_minus1, settings, "uint8_t", "sps_max_sub_layers_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sps_seq_parameter_set_id, settings, "uint8_t", "sps_seq_parameter_set_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bit_depth_luma_minus8, settings, "uint8_t", "bit_depth_luma_minus8", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bit_depth_chroma_minus8, settings, "uint8_t", "bit_depth_chroma_minus8", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.log2_max_pic_order_cnt_lsb_minus4, settings, "uint8_t", "log2_max_pic_order_cnt_lsb_minus4", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.log2_min_luma_coding_block_size_minus3, settings, "uint8_t", "log2_min_luma_coding_block_size_minus3", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.log2_diff_max_min_luma_coding_block_size, settings, "uint8_t", "log2_diff_max_min_luma_coding_block_size", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.log2_min_luma_transform_block_size_minus2, settings, "uint8_t", "log2_min_luma_transform_block_size_minus2", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.log2_diff_max_min_luma_transform_block_size, settings, "uint8_t", "log2_diff_max_min_luma_transform_block_size", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.max_transform_hierarchy_depth_inter, settings, "uint8_t", "max_transform_hierarchy_depth_inter", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.max_transform_hierarchy_depth_intra, settings, "uint8_t", "max_transform_hierarchy_depth_intra", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.num_short_term_ref_pic_sets, settings, "uint8_t", "num_short_term_ref_pic_sets", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.num_long_term_ref_pics_sps, settings, "uint8_t", "num_long_term_ref_pics_sps", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pcm_sample_bit_depth_luma_minus1, settings, "uint8_t", "pcm_sample_bit_depth_luma_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pcm_sample_bit_depth_chroma_minus1, settings, "uint8_t", "pcm_sample_bit_depth_chroma_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.log2_min_pcm_luma_coding_block_size_minus3, settings, "uint8_t", "log2_min_pcm_luma_coding_block_size_minus3", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.log2_diff_max_min_pcm_luma_coding_block_size, settings, "uint8_t", "log2_diff_max_min_pcm_luma_coding_block_size", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved1, settings, "uint8_t", "reserved1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved2, settings, "uint8_t", "reserved2", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.palette_max_size, settings, "uint8_t", "palette_max_size", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.delta_palette_max_predictor_size, settings, "uint8_t", "delta_palette_max_predictor_size", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.motion_vector_resolution_control_idc, settings, "uint8_t", "motion_vector_resolution_control_idc", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sps_num_palette_predictor_initializers_minus1, settings, "uint8_t", "sps_num_palette_predictor_initializers_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.conf_win_left_offset, settings, "uint32_t", "conf_win_left_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.conf_win_right_offset, settings, "uint32_t", "conf_win_right_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.conf_win_top_offset, settings, "uint32_t", "conf_win_top_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.conf_win_bottom_offset, settings, "uint32_t", "conf_win_bottom_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pProfileTierLevel, settings, "const StdVideoH265ProfileTierLevel*", "pProfileTierLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265ProfileTierLevel); + dump_separate_members(settings); + dump_pointer(object.pDecPicBufMgr, settings, "const StdVideoH265DecPicBufMgr*", "pDecPicBufMgr", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265DecPicBufMgr); + dump_separate_members(settings); + dump_pointer(object.pScalingLists, settings, "const StdVideoH265ScalingLists*", "pScalingLists", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265ScalingLists); + dump_separate_members(settings); + dump_pointer_array(object.pShortTermRefPicSet, object.num_short_term_ref_pic_sets, settings, "const StdVideoH265ShortTermRefPicSet*", "pShortTermRefPicSet", "const StdVideoH265ShortTermRefPicSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265ShortTermRefPicSet); + dump_separate_members(settings); + dump_pointer(object.pLongTermRefPicsSps, settings, "const StdVideoH265LongTermRefPicsSps*", "pLongTermRefPicsSps", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265LongTermRefPicsSps); + dump_separate_members(settings); + dump_pointer(object.pSequenceParameterSetVui, settings, "const StdVideoH265SequenceParameterSetVui*", "pSequenceParameterSetVui", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265SequenceParameterSetVui); + dump_separate_members(settings); + dump_pointer(object.pPredictorPaletteEntries, settings, "const StdVideoH265PredictorPaletteEntries*", "pPredictorPaletteEntries", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265PredictorPaletteEntries); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoH265PpsFlags(const StdVideoH265PpsFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.dependent_slice_segments_enabled_flag, settings, "uint32_t: 1", "dependent_slice_segments_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.output_flag_present_flag, settings, "uint32_t: 1", "output_flag_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sign_data_hiding_enabled_flag, settings, "uint32_t: 1", "sign_data_hiding_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.cabac_init_present_flag, settings, "uint32_t: 1", "cabac_init_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.constrained_intra_pred_flag, settings, "uint32_t: 1", "constrained_intra_pred_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.transform_skip_enabled_flag, settings, "uint32_t: 1", "transform_skip_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.cu_qp_delta_enabled_flag, settings, "uint32_t: 1", "cu_qp_delta_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pps_slice_chroma_qp_offsets_present_flag, settings, "uint32_t: 1", "pps_slice_chroma_qp_offsets_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.weighted_pred_flag, settings, "uint32_t: 1", "weighted_pred_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.weighted_bipred_flag, settings, "uint32_t: 1", "weighted_bipred_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.transquant_bypass_enabled_flag, settings, "uint32_t: 1", "transquant_bypass_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tiles_enabled_flag, settings, "uint32_t: 1", "tiles_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.entropy_coding_sync_enabled_flag, settings, "uint32_t: 1", "entropy_coding_sync_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.uniform_spacing_flag, settings, "uint32_t: 1", "uniform_spacing_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.loop_filter_across_tiles_enabled_flag, settings, "uint32_t: 1", "loop_filter_across_tiles_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pps_loop_filter_across_slices_enabled_flag, settings, "uint32_t: 1", "pps_loop_filter_across_slices_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.deblocking_filter_control_present_flag, settings, "uint32_t: 1", "deblocking_filter_control_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.deblocking_filter_override_enabled_flag, settings, "uint32_t: 1", "deblocking_filter_override_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pps_deblocking_filter_disabled_flag, settings, "uint32_t: 1", "pps_deblocking_filter_disabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pps_scaling_list_data_present_flag, settings, "uint32_t: 1", "pps_scaling_list_data_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.lists_modification_present_flag, settings, "uint32_t: 1", "lists_modification_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.slice_segment_header_extension_present_flag, settings, "uint32_t: 1", "slice_segment_header_extension_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pps_extension_present_flag, settings, "uint32_t: 1", "pps_extension_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.cross_component_prediction_enabled_flag, settings, "uint32_t: 1", "cross_component_prediction_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.chroma_qp_offset_list_enabled_flag, settings, "uint32_t: 1", "chroma_qp_offset_list_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pps_curr_pic_ref_enabled_flag, settings, "uint32_t: 1", "pps_curr_pic_ref_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.residual_adaptive_colour_transform_enabled_flag, settings, "uint32_t: 1", "residual_adaptive_colour_transform_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pps_slice_act_qp_offsets_present_flag, settings, "uint32_t: 1", "pps_slice_act_qp_offsets_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pps_palette_predictor_initializers_present_flag, settings, "uint32_t: 1", "pps_palette_predictor_initializers_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.monochrome_palette_flag, settings, "uint32_t: 1", "monochrome_palette_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pps_range_extension_flag, settings, "uint32_t: 1", "pps_range_extension_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoH265PictureParameterSet(const StdVideoH265PictureParameterSet& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_StdVideoH265PpsFlags(object.flags, settings, "StdVideoH265PpsFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pps_pic_parameter_set_id, settings, "uint8_t", "pps_pic_parameter_set_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pps_seq_parameter_set_id, settings, "uint8_t", "pps_seq_parameter_set_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sps_video_parameter_set_id, settings, "uint8_t", "sps_video_parameter_set_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.num_extra_slice_header_bits, settings, "uint8_t", "num_extra_slice_header_bits", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.num_ref_idx_l0_default_active_minus1, settings, "uint8_t", "num_ref_idx_l0_default_active_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.num_ref_idx_l1_default_active_minus1, settings, "uint8_t", "num_ref_idx_l1_default_active_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.init_qp_minus26, settings, "int8_t", "init_qp_minus26", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.diff_cu_qp_delta_depth, settings, "uint8_t", "diff_cu_qp_delta_depth", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pps_cb_qp_offset, settings, "int8_t", "pps_cb_qp_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pps_cr_qp_offset, settings, "int8_t", "pps_cr_qp_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pps_beta_offset_div2, settings, "int8_t", "pps_beta_offset_div2", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pps_tc_offset_div2, settings, "int8_t", "pps_tc_offset_div2", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.log2_parallel_merge_level_minus2, settings, "uint8_t", "log2_parallel_merge_level_minus2", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.log2_max_transform_skip_block_size_minus2, settings, "uint8_t", "log2_max_transform_skip_block_size_minus2", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.diff_cu_chroma_qp_offset_depth, settings, "uint8_t", "diff_cu_chroma_qp_offset_depth", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.chroma_qp_offset_list_len_minus1, settings, "uint8_t", "chroma_qp_offset_list_len_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.cb_qp_offset_list, STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE, settings, "int8_t[STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE]", "cb_qp_offset_list", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.cr_qp_offset_list, STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE, settings, "int8_t[STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE]", "cr_qp_offset_list", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.log2_sao_offset_scale_luma, settings, "uint8_t", "log2_sao_offset_scale_luma", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.log2_sao_offset_scale_chroma, settings, "uint8_t", "log2_sao_offset_scale_chroma", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pps_act_y_qp_offset_plus5, settings, "int8_t", "pps_act_y_qp_offset_plus5", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pps_act_cb_qp_offset_plus5, settings, "int8_t", "pps_act_cb_qp_offset_plus5", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pps_act_cr_qp_offset_plus3, settings, "int8_t", "pps_act_cr_qp_offset_plus3", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pps_num_palette_predictor_initializers, settings, "uint8_t", "pps_num_palette_predictor_initializers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.luma_bit_depth_entry_minus8, settings, "uint8_t", "luma_bit_depth_entry_minus8", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.chroma_bit_depth_entry_minus8, settings, "uint8_t", "chroma_bit_depth_entry_minus8", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.num_tile_columns_minus1, settings, "uint8_t", "num_tile_columns_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.num_tile_rows_minus1, settings, "uint8_t", "num_tile_rows_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved1, settings, "uint8_t", "reserved1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved2, settings, "uint8_t", "reserved2", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.column_width_minus1, STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE, settings, "uint16_t[STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE]", "column_width_minus1", "uint16_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.row_height_minus1, STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE, settings, "uint16_t[STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE]", "row_height_minus1", "uint16_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.reserved3, settings, "uint32_t", "reserved3", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pScalingLists, settings, "const StdVideoH265ScalingLists*", "pScalingLists", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265ScalingLists); + dump_separate_members(settings); + dump_pointer(object.pPredictorPaletteEntries, settings, "const StdVideoH265PredictorPaletteEntries*", "pPredictorPaletteEntries", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265PredictorPaletteEntries); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoDecodeH265PictureInfoFlags(const StdVideoDecodeH265PictureInfoFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.IrapPicFlag, settings, "uint32_t: 1", "IrapPicFlag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.IdrPicFlag, settings, "uint32_t: 1", "IdrPicFlag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.IsReference, settings, "uint32_t: 1", "IsReference", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.short_term_ref_pic_set_sps_flag, settings, "uint32_t: 1", "short_term_ref_pic_set_sps_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoDecodeH265PictureInfo(const StdVideoDecodeH265PictureInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_StdVideoDecodeH265PictureInfoFlags(object.flags, settings, "StdVideoDecodeH265PictureInfoFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sps_video_parameter_set_id, settings, "uint8_t", "sps_video_parameter_set_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pps_seq_parameter_set_id, settings, "uint8_t", "pps_seq_parameter_set_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pps_pic_parameter_set_id, settings, "uint8_t", "pps_pic_parameter_set_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.NumDeltaPocsOfRefRpsIdx, settings, "uint8_t", "NumDeltaPocsOfRefRpsIdx", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.PicOrderCntVal, settings, "int32_t", "PicOrderCntVal", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.NumBitsForSTRefPicSetInSlice, settings, "uint16_t", "NumBitsForSTRefPicSetInSlice", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved, settings, "uint16_t", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.RefPicSetStCurrBefore, STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE, settings, "uint8_t[STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE]", "RefPicSetStCurrBefore", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.RefPicSetStCurrAfter, STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE, settings, "uint8_t[STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE]", "RefPicSetStCurrAfter", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.RefPicSetLtCurr, STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE, settings, "uint8_t[STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE]", "RefPicSetLtCurr", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoDecodeH265ReferenceInfoFlags(const StdVideoDecodeH265ReferenceInfoFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.used_for_long_term_reference, settings, "uint32_t: 1", "used_for_long_term_reference", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.unused_for_reference, settings, "uint32_t: 1", "unused_for_reference", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoDecodeH265ReferenceInfo(const StdVideoDecodeH265ReferenceInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_StdVideoDecodeH265ReferenceInfoFlags(object.flags, settings, "StdVideoDecodeH265ReferenceInfoFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.PicOrderCntVal, settings, "int32_t", "PicOrderCntVal", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoEncodeH265WeightTableFlags(const StdVideoEncodeH265WeightTableFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.luma_weight_l0_flag, settings, "uint16_t", "luma_weight_l0_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.chroma_weight_l0_flag, settings, "uint16_t", "chroma_weight_l0_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.luma_weight_l1_flag, settings, "uint16_t", "luma_weight_l1_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.chroma_weight_l1_flag, settings, "uint16_t", "chroma_weight_l1_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoEncodeH265WeightTable(const StdVideoEncodeH265WeightTable& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_StdVideoEncodeH265WeightTableFlags(object.flags, settings, "StdVideoEncodeH265WeightTableFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.luma_log2_weight_denom, settings, "uint8_t", "luma_log2_weight_denom", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.delta_chroma_log2_weight_denom, settings, "int8_t", "delta_chroma_log2_weight_denom", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.delta_luma_weight_l0, STD_VIDEO_H265_MAX_NUM_LIST_REF, settings, "int8_t[STD_VIDEO_H265_MAX_NUM_LIST_REF]", "delta_luma_weight_l0", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.luma_offset_l0, STD_VIDEO_H265_MAX_NUM_LIST_REF, settings, "int8_t[STD_VIDEO_H265_MAX_NUM_LIST_REF]", "luma_offset_l0", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_double_array(object.delta_chroma_weight_l0, STD_VIDEO_H265_MAX_NUM_LIST_REF, STD_VIDEO_H265_MAX_CHROMA_PLANES, settings, "int8_t[STD_VIDEO_H265_MAX_NUM_LIST_REF][STD_VIDEO_H265_MAX_CHROMA_PLANES]", "delta_chroma_weight_l0", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_double_array(object.delta_chroma_offset_l0, STD_VIDEO_H265_MAX_NUM_LIST_REF, STD_VIDEO_H265_MAX_CHROMA_PLANES, settings, "int8_t[STD_VIDEO_H265_MAX_NUM_LIST_REF][STD_VIDEO_H265_MAX_CHROMA_PLANES]", "delta_chroma_offset_l0", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.delta_luma_weight_l1, STD_VIDEO_H265_MAX_NUM_LIST_REF, settings, "int8_t[STD_VIDEO_H265_MAX_NUM_LIST_REF]", "delta_luma_weight_l1", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.luma_offset_l1, STD_VIDEO_H265_MAX_NUM_LIST_REF, settings, "int8_t[STD_VIDEO_H265_MAX_NUM_LIST_REF]", "luma_offset_l1", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_double_array(object.delta_chroma_weight_l1, STD_VIDEO_H265_MAX_NUM_LIST_REF, STD_VIDEO_H265_MAX_CHROMA_PLANES, settings, "int8_t[STD_VIDEO_H265_MAX_NUM_LIST_REF][STD_VIDEO_H265_MAX_CHROMA_PLANES]", "delta_chroma_weight_l1", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_double_array(object.delta_chroma_offset_l1, STD_VIDEO_H265_MAX_NUM_LIST_REF, STD_VIDEO_H265_MAX_CHROMA_PLANES, settings, "int8_t[STD_VIDEO_H265_MAX_NUM_LIST_REF][STD_VIDEO_H265_MAX_CHROMA_PLANES]", "delta_chroma_offset_l1", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoEncodeH265SliceSegmentHeaderFlags(const StdVideoEncodeH265SliceSegmentHeaderFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.first_slice_segment_in_pic_flag, settings, "uint32_t: 1", "first_slice_segment_in_pic_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dependent_slice_segment_flag, settings, "uint32_t: 1", "dependent_slice_segment_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.slice_sao_luma_flag, settings, "uint32_t: 1", "slice_sao_luma_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.slice_sao_chroma_flag, settings, "uint32_t: 1", "slice_sao_chroma_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.num_ref_idx_active_override_flag, settings, "uint32_t: 1", "num_ref_idx_active_override_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.mvd_l1_zero_flag, settings, "uint32_t: 1", "mvd_l1_zero_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.cabac_init_flag, settings, "uint32_t: 1", "cabac_init_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.cu_chroma_qp_offset_enabled_flag, settings, "uint32_t: 1", "cu_chroma_qp_offset_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.deblocking_filter_override_flag, settings, "uint32_t: 1", "deblocking_filter_override_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.slice_deblocking_filter_disabled_flag, settings, "uint32_t: 1", "slice_deblocking_filter_disabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.collocated_from_l0_flag, settings, "uint32_t: 1", "collocated_from_l0_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.slice_loop_filter_across_slices_enabled_flag, settings, "uint32_t: 1", "slice_loop_filter_across_slices_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved, settings, "uint32_t: 20", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoEncodeH265SliceSegmentHeader(const StdVideoEncodeH265SliceSegmentHeader& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_StdVideoEncodeH265SliceSegmentHeaderFlags(object.flags, settings, "StdVideoEncodeH265SliceSegmentHeaderFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoH265SliceType(object.slice_type, settings, "StdVideoH265SliceType", "slice_type", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.slice_segment_address, settings, "uint32_t", "slice_segment_address", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.collocated_ref_idx, settings, "uint8_t", "collocated_ref_idx", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.MaxNumMergeCand, settings, "uint8_t", "MaxNumMergeCand", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.slice_cb_qp_offset, settings, "int8_t", "slice_cb_qp_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.slice_cr_qp_offset, settings, "int8_t", "slice_cr_qp_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.slice_beta_offset_div2, settings, "int8_t", "slice_beta_offset_div2", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.slice_tc_offset_div2, settings, "int8_t", "slice_tc_offset_div2", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.slice_act_y_qp_offset, settings, "int8_t", "slice_act_y_qp_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.slice_act_cb_qp_offset, settings, "int8_t", "slice_act_cb_qp_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.slice_act_cr_qp_offset, settings, "int8_t", "slice_act_cr_qp_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.slice_qp_delta, settings, "int8_t", "slice_qp_delta", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved1, settings, "uint16_t", "reserved1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pWeightTable, settings, "const StdVideoEncodeH265WeightTable*", "pWeightTable", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeH265WeightTable); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoEncodeH265ReferenceListsInfoFlags(const StdVideoEncodeH265ReferenceListsInfoFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.ref_pic_list_modification_flag_l0, settings, "uint32_t: 1", "ref_pic_list_modification_flag_l0", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.ref_pic_list_modification_flag_l1, settings, "uint32_t: 1", "ref_pic_list_modification_flag_l1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved, settings, "uint32_t: 30", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoEncodeH265ReferenceListsInfo(const StdVideoEncodeH265ReferenceListsInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_StdVideoEncodeH265ReferenceListsInfoFlags(object.flags, settings, "StdVideoEncodeH265ReferenceListsInfoFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.num_ref_idx_l0_active_minus1, settings, "uint8_t", "num_ref_idx_l0_active_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.num_ref_idx_l1_active_minus1, settings, "uint8_t", "num_ref_idx_l1_active_minus1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.RefPicList0, STD_VIDEO_H265_MAX_NUM_LIST_REF, settings, "uint8_t[STD_VIDEO_H265_MAX_NUM_LIST_REF]", "RefPicList0", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.RefPicList1, STD_VIDEO_H265_MAX_NUM_LIST_REF, settings, "uint8_t[STD_VIDEO_H265_MAX_NUM_LIST_REF]", "RefPicList1", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.list_entry_l0, STD_VIDEO_H265_MAX_NUM_LIST_REF, settings, "uint8_t[STD_VIDEO_H265_MAX_NUM_LIST_REF]", "list_entry_l0", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.list_entry_l1, STD_VIDEO_H265_MAX_NUM_LIST_REF, settings, "uint8_t[STD_VIDEO_H265_MAX_NUM_LIST_REF]", "list_entry_l1", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoEncodeH265PictureInfoFlags(const StdVideoEncodeH265PictureInfoFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.is_reference, settings, "uint32_t: 1", "is_reference", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.IrapPicFlag, settings, "uint32_t: 1", "IrapPicFlag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.used_for_long_term_reference, settings, "uint32_t: 1", "used_for_long_term_reference", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.discardable_flag, settings, "uint32_t: 1", "discardable_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.cross_layer_bla_flag, settings, "uint32_t: 1", "cross_layer_bla_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pic_output_flag, settings, "uint32_t: 1", "pic_output_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.no_output_of_prior_pics_flag, settings, "uint32_t: 1", "no_output_of_prior_pics_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.short_term_ref_pic_set_sps_flag, settings, "uint32_t: 1", "short_term_ref_pic_set_sps_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.slice_temporal_mvp_enabled_flag, settings, "uint32_t: 1", "slice_temporal_mvp_enabled_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved, settings, "uint32_t: 23", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoEncodeH265LongTermRefPics(const StdVideoEncodeH265LongTermRefPics& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.num_long_term_sps, settings, "uint8_t", "num_long_term_sps", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.num_long_term_pics, settings, "uint8_t", "num_long_term_pics", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.lt_idx_sps, STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS, settings, "uint8_t[STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS]", "lt_idx_sps", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.poc_lsb_lt, STD_VIDEO_H265_MAX_LONG_TERM_PICS, settings, "uint8_t[STD_VIDEO_H265_MAX_LONG_TERM_PICS]", "poc_lsb_lt", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.used_by_curr_pic_lt_flag, settings, "uint16_t", "used_by_curr_pic_lt_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.delta_poc_msb_present_flag, STD_VIDEO_H265_MAX_DELTA_POC, settings, "uint8_t[STD_VIDEO_H265_MAX_DELTA_POC]", "delta_poc_msb_present_flag", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.delta_poc_msb_cycle_lt, STD_VIDEO_H265_MAX_DELTA_POC, settings, "uint8_t[STD_VIDEO_H265_MAX_DELTA_POC]", "delta_poc_msb_cycle_lt", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoEncodeH265PictureInfo(const StdVideoEncodeH265PictureInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_StdVideoEncodeH265PictureInfoFlags(object.flags, settings, "StdVideoEncodeH265PictureInfoFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoH265PictureType(object.pic_type, settings, "StdVideoH265PictureType", "pic_type", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sps_video_parameter_set_id, settings, "uint8_t", "sps_video_parameter_set_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pps_seq_parameter_set_id, settings, "uint8_t", "pps_seq_parameter_set_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pps_pic_parameter_set_id, settings, "uint8_t", "pps_pic_parameter_set_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.short_term_ref_pic_set_idx, settings, "uint8_t", "short_term_ref_pic_set_idx", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.PicOrderCntVal, settings, "int32_t", "PicOrderCntVal", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.TemporalId, settings, "uint8_t", "TemporalId", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.reserved1, 7, settings, "uint8_t[7]", "reserved1", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_pointer(object.pRefLists, settings, "const StdVideoEncodeH265ReferenceListsInfo*", "pRefLists", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeH265ReferenceListsInfo); + dump_separate_members(settings); + dump_pointer(object.pShortTermRefPicSet, settings, "const StdVideoH265ShortTermRefPicSet*", "pShortTermRefPicSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265ShortTermRefPicSet); + dump_separate_members(settings); + dump_pointer(object.pLongTermRefPics, settings, "const StdVideoEncodeH265LongTermRefPics*", "pLongTermRefPics", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeH265LongTermRefPics); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoEncodeH265ReferenceInfoFlags(const StdVideoEncodeH265ReferenceInfoFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.used_for_long_term_reference, settings, "uint32_t: 1", "used_for_long_term_reference", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.unused_for_reference, settings, "uint32_t: 1", "unused_for_reference", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved, settings, "uint32_t: 30", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoEncodeH265ReferenceInfo(const StdVideoEncodeH265ReferenceInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_StdVideoEncodeH265ReferenceInfoFlags(object.flags, settings, "StdVideoEncodeH265ReferenceInfoFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoH265PictureType(object.pic_type, settings, "StdVideoH265PictureType", "pic_type", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.PicOrderCntVal, settings, "int32_t", "PicOrderCntVal", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.TemporalId, settings, "uint8_t", "TemporalId", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoAV1ColorConfigFlags(const StdVideoAV1ColorConfigFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.mono_chrome, settings, "uint32_t: 1", "mono_chrome", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.color_range, settings, "uint32_t: 1", "color_range", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.separate_uv_delta_q, settings, "uint32_t: 1", "separate_uv_delta_q", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.color_description_present_flag, settings, "uint32_t: 1", "color_description_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved, settings, "uint32_t: 28", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoAV1ColorConfig(const StdVideoAV1ColorConfig& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_StdVideoAV1ColorConfigFlags(object.flags, settings, "StdVideoAV1ColorConfigFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.BitDepth, settings, "uint8_t", "BitDepth", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.subsampling_x, settings, "uint8_t", "subsampling_x", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.subsampling_y, settings, "uint8_t", "subsampling_y", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved1, settings, "uint8_t", "reserved1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoAV1ColorPrimaries(object.color_primaries, settings, "StdVideoAV1ColorPrimaries", "color_primaries", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoAV1TransferCharacteristics(object.transfer_characteristics, settings, "StdVideoAV1TransferCharacteristics", "transfer_characteristics", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoAV1MatrixCoefficients(object.matrix_coefficients, settings, "StdVideoAV1MatrixCoefficients", "matrix_coefficients", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoAV1ChromaSamplePosition(object.chroma_sample_position, settings, "StdVideoAV1ChromaSamplePosition", "chroma_sample_position", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoAV1TimingInfoFlags(const StdVideoAV1TimingInfoFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.equal_picture_interval, settings, "uint32_t: 1", "equal_picture_interval", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved, settings, "uint32_t: 31", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoAV1TimingInfo(const StdVideoAV1TimingInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_StdVideoAV1TimingInfoFlags(object.flags, settings, "StdVideoAV1TimingInfoFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.num_units_in_display_tick, settings, "uint32_t", "num_units_in_display_tick", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.time_scale, settings, "uint32_t", "time_scale", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.num_ticks_per_picture_minus_1, settings, "uint32_t", "num_ticks_per_picture_minus_1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoAV1LoopFilterFlags(const StdVideoAV1LoopFilterFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.loop_filter_delta_enabled, settings, "uint32_t: 1", "loop_filter_delta_enabled", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.loop_filter_delta_update, settings, "uint32_t: 1", "loop_filter_delta_update", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved, settings, "uint32_t: 30", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoAV1LoopFilter(const StdVideoAV1LoopFilter& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_StdVideoAV1LoopFilterFlags(object.flags, settings, "StdVideoAV1LoopFilterFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.loop_filter_level, STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS, settings, "uint8_t[STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS]", "loop_filter_level", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.loop_filter_sharpness, settings, "uint8_t", "loop_filter_sharpness", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.update_ref_delta, settings, "uint8_t", "update_ref_delta", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.loop_filter_ref_deltas, STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME, settings, "int8_t[STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME]", "loop_filter_ref_deltas", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.update_mode_delta, settings, "uint8_t", "update_mode_delta", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.loop_filter_mode_deltas, STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS, settings, "int8_t[STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS]", "loop_filter_mode_deltas", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoAV1QuantizationFlags(const StdVideoAV1QuantizationFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.using_qmatrix, settings, "uint32_t: 1", "using_qmatrix", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.diff_uv_delta, settings, "uint32_t: 1", "diff_uv_delta", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved, settings, "uint32_t: 30", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoAV1Quantization(const StdVideoAV1Quantization& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_StdVideoAV1QuantizationFlags(object.flags, settings, "StdVideoAV1QuantizationFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.base_q_idx, settings, "uint8_t", "base_q_idx", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.DeltaQYDc, settings, "int8_t", "DeltaQYDc", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.DeltaQUDc, settings, "int8_t", "DeltaQUDc", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.DeltaQUAc, settings, "int8_t", "DeltaQUAc", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.DeltaQVDc, settings, "int8_t", "DeltaQVDc", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.DeltaQVAc, settings, "int8_t", "DeltaQVAc", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.qm_y, settings, "uint8_t", "qm_y", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.qm_u, settings, "uint8_t", "qm_u", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.qm_v, settings, "uint8_t", "qm_v", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoAV1Segmentation(const StdVideoAV1Segmentation& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_single_array(object.FeatureEnabled, STD_VIDEO_AV1_MAX_SEGMENTS, settings, "uint8_t[STD_VIDEO_AV1_MAX_SEGMENTS]", "FeatureEnabled", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_double_array(object.FeatureData, STD_VIDEO_AV1_MAX_SEGMENTS, STD_VIDEO_AV1_SEG_LVL_MAX, settings, "int16_t[STD_VIDEO_AV1_MAX_SEGMENTS][STD_VIDEO_AV1_SEG_LVL_MAX]", "FeatureData", "int16_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoAV1TileInfoFlags(const StdVideoAV1TileInfoFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.uniform_tile_spacing_flag, settings, "uint32_t: 1", "uniform_tile_spacing_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved, settings, "uint32_t: 31", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoAV1TileInfo(const StdVideoAV1TileInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_StdVideoAV1TileInfoFlags(object.flags, settings, "StdVideoAV1TileInfoFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.TileCols, settings, "uint8_t", "TileCols", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.TileRows, settings, "uint8_t", "TileRows", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.context_update_tile_id, settings, "uint16_t", "context_update_tile_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tile_size_bytes_minus_1, settings, "uint8_t", "tile_size_bytes_minus_1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.reserved1, 7, settings, "uint8_t[7]", "reserved1", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(object.pMiColStarts, object.TileCols, settings, "const uint16_t*", "pMiColStarts", "const uint16_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(object.pMiRowStarts, object.TileRows, settings, "const uint16_t*", "pMiRowStarts", "const uint16_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(object.pWidthInSbsMinus1, object.TileCols, settings, "const uint16_t*", "pWidthInSbsMinus1", "const uint16_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(object.pHeightInSbsMinus1, object.TileRows, settings, "const uint16_t*", "pHeightInSbsMinus1", "const uint16_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoAV1CDEF(const StdVideoAV1CDEF& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.cdef_damping_minus_3, settings, "uint8_t", "cdef_damping_minus_3", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.cdef_bits, settings, "uint8_t", "cdef_bits", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.cdef_y_pri_strength, STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS, settings, "uint8_t[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS]", "cdef_y_pri_strength", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.cdef_y_sec_strength, STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS, settings, "uint8_t[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS]", "cdef_y_sec_strength", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.cdef_uv_pri_strength, STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS, settings, "uint8_t[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS]", "cdef_uv_pri_strength", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.cdef_uv_sec_strength, STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS, settings, "uint8_t[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS]", "cdef_uv_sec_strength", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoAV1LoopRestoration(const StdVideoAV1LoopRestoration& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_single_array(object.FrameRestorationType, STD_VIDEO_AV1_MAX_NUM_PLANES, settings, "StdVideoAV1FrameRestorationType[STD_VIDEO_AV1_MAX_NUM_PLANES]", "FrameRestorationType", "StdVideoAV1FrameRestorationType", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1FrameRestorationType); + dump_separate_members(settings); + dump_single_array(object.LoopRestorationSize, STD_VIDEO_AV1_MAX_NUM_PLANES, settings, "uint16_t[STD_VIDEO_AV1_MAX_NUM_PLANES]", "LoopRestorationSize", "uint16_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoAV1GlobalMotion(const StdVideoAV1GlobalMotion& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_single_array(object.GmType, STD_VIDEO_AV1_NUM_REF_FRAMES, settings, "uint8_t[STD_VIDEO_AV1_NUM_REF_FRAMES]", "GmType", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_double_array(object.gm_params, STD_VIDEO_AV1_NUM_REF_FRAMES, STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS, settings, "int32_t[STD_VIDEO_AV1_NUM_REF_FRAMES][STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS]", "gm_params", "int32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoAV1FilmGrainFlags(const StdVideoAV1FilmGrainFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.chroma_scaling_from_luma, settings, "uint32_t: 1", "chroma_scaling_from_luma", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.overlap_flag, settings, "uint32_t: 1", "overlap_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.clip_to_restricted_range, settings, "uint32_t: 1", "clip_to_restricted_range", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.update_grain, settings, "uint32_t: 1", "update_grain", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved, settings, "uint32_t: 28", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoAV1FilmGrain(const StdVideoAV1FilmGrain& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_StdVideoAV1FilmGrainFlags(object.flags, settings, "StdVideoAV1FilmGrainFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.grain_scaling_minus_8, settings, "uint8_t", "grain_scaling_minus_8", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.ar_coeff_lag, settings, "uint8_t", "ar_coeff_lag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.ar_coeff_shift_minus_6, settings, "uint8_t", "ar_coeff_shift_minus_6", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.grain_scale_shift, settings, "uint8_t", "grain_scale_shift", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.grain_seed, settings, "uint16_t", "grain_seed", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.film_grain_params_ref_idx, settings, "uint8_t", "film_grain_params_ref_idx", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.num_y_points, settings, "uint8_t", "num_y_points", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.point_y_value, STD_VIDEO_AV1_MAX_NUM_Y_POINTS, settings, "uint8_t[STD_VIDEO_AV1_MAX_NUM_Y_POINTS]", "point_y_value", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.point_y_scaling, STD_VIDEO_AV1_MAX_NUM_Y_POINTS, settings, "uint8_t[STD_VIDEO_AV1_MAX_NUM_Y_POINTS]", "point_y_scaling", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.num_cb_points, settings, "uint8_t", "num_cb_points", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.point_cb_value, STD_VIDEO_AV1_MAX_NUM_CB_POINTS, settings, "uint8_t[STD_VIDEO_AV1_MAX_NUM_CB_POINTS]", "point_cb_value", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.point_cb_scaling, STD_VIDEO_AV1_MAX_NUM_CB_POINTS, settings, "uint8_t[STD_VIDEO_AV1_MAX_NUM_CB_POINTS]", "point_cb_scaling", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.num_cr_points, settings, "uint8_t", "num_cr_points", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.point_cr_value, STD_VIDEO_AV1_MAX_NUM_CR_POINTS, settings, "uint8_t[STD_VIDEO_AV1_MAX_NUM_CR_POINTS]", "point_cr_value", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.point_cr_scaling, STD_VIDEO_AV1_MAX_NUM_CR_POINTS, settings, "uint8_t[STD_VIDEO_AV1_MAX_NUM_CR_POINTS]", "point_cr_scaling", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.ar_coeffs_y_plus_128, STD_VIDEO_AV1_MAX_NUM_POS_LUMA, settings, "int8_t[STD_VIDEO_AV1_MAX_NUM_POS_LUMA]", "ar_coeffs_y_plus_128", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.ar_coeffs_cb_plus_128, STD_VIDEO_AV1_MAX_NUM_POS_CHROMA, settings, "int8_t[STD_VIDEO_AV1_MAX_NUM_POS_CHROMA]", "ar_coeffs_cb_plus_128", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.ar_coeffs_cr_plus_128, STD_VIDEO_AV1_MAX_NUM_POS_CHROMA, settings, "int8_t[STD_VIDEO_AV1_MAX_NUM_POS_CHROMA]", "ar_coeffs_cr_plus_128", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.cb_mult, settings, "uint8_t", "cb_mult", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.cb_luma_mult, settings, "uint8_t", "cb_luma_mult", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.cb_offset, settings, "uint16_t", "cb_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.cr_mult, settings, "uint8_t", "cr_mult", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.cr_luma_mult, settings, "uint8_t", "cr_luma_mult", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.cr_offset, settings, "uint16_t", "cr_offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoAV1SequenceHeaderFlags(const StdVideoAV1SequenceHeaderFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.still_picture, settings, "uint32_t: 1", "still_picture", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reduced_still_picture_header, settings, "uint32_t: 1", "reduced_still_picture_header", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.use_128x128_superblock, settings, "uint32_t: 1", "use_128x128_superblock", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.enable_filter_intra, settings, "uint32_t: 1", "enable_filter_intra", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.enable_intra_edge_filter, settings, "uint32_t: 1", "enable_intra_edge_filter", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.enable_interintra_compound, settings, "uint32_t: 1", "enable_interintra_compound", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.enable_masked_compound, settings, "uint32_t: 1", "enable_masked_compound", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.enable_warped_motion, settings, "uint32_t: 1", "enable_warped_motion", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.enable_dual_filter, settings, "uint32_t: 1", "enable_dual_filter", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.enable_order_hint, settings, "uint32_t: 1", "enable_order_hint", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.enable_jnt_comp, settings, "uint32_t: 1", "enable_jnt_comp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.enable_ref_frame_mvs, settings, "uint32_t: 1", "enable_ref_frame_mvs", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.frame_id_numbers_present_flag, settings, "uint32_t: 1", "frame_id_numbers_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.enable_superres, settings, "uint32_t: 1", "enable_superres", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.enable_cdef, settings, "uint32_t: 1", "enable_cdef", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.enable_restoration, settings, "uint32_t: 1", "enable_restoration", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.film_grain_params_present, settings, "uint32_t: 1", "film_grain_params_present", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.timing_info_present_flag, settings, "uint32_t: 1", "timing_info_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.initial_display_delay_present_flag, settings, "uint32_t: 1", "initial_display_delay_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved, settings, "uint32_t: 13", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoAV1SequenceHeader(const StdVideoAV1SequenceHeader& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_StdVideoAV1SequenceHeaderFlags(object.flags, settings, "StdVideoAV1SequenceHeaderFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoAV1Profile(object.seq_profile, settings, "StdVideoAV1Profile", "seq_profile", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.frame_width_bits_minus_1, settings, "uint8_t", "frame_width_bits_minus_1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.frame_height_bits_minus_1, settings, "uint8_t", "frame_height_bits_minus_1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.max_frame_width_minus_1, settings, "uint16_t", "max_frame_width_minus_1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.max_frame_height_minus_1, settings, "uint16_t", "max_frame_height_minus_1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.delta_frame_id_length_minus_2, settings, "uint8_t", "delta_frame_id_length_minus_2", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.additional_frame_id_length_minus_1, settings, "uint8_t", "additional_frame_id_length_minus_1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.order_hint_bits_minus_1, settings, "uint8_t", "order_hint_bits_minus_1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.seq_force_integer_mv, settings, "uint8_t", "seq_force_integer_mv", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.seq_force_screen_content_tools, settings, "uint8_t", "seq_force_screen_content_tools", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.reserved1, 5, settings, "uint8_t[5]", "reserved1", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_pointer(object.pColorConfig, settings, "const StdVideoAV1ColorConfig*", "pColorConfig", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1ColorConfig); + dump_separate_members(settings); + dump_pointer(object.pTimingInfo, settings, "const StdVideoAV1TimingInfo*", "pTimingInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1TimingInfo); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoDecodeAV1PictureInfoFlags(const StdVideoDecodeAV1PictureInfoFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.error_resilient_mode, settings, "uint32_t: 1", "error_resilient_mode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.disable_cdf_update, settings, "uint32_t: 1", "disable_cdf_update", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.use_superres, settings, "uint32_t: 1", "use_superres", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.render_and_frame_size_different, settings, "uint32_t: 1", "render_and_frame_size_different", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.allow_screen_content_tools, settings, "uint32_t: 1", "allow_screen_content_tools", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.is_filter_switchable, settings, "uint32_t: 1", "is_filter_switchable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.force_integer_mv, settings, "uint32_t: 1", "force_integer_mv", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.frame_size_override_flag, settings, "uint32_t: 1", "frame_size_override_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.buffer_removal_time_present_flag, settings, "uint32_t: 1", "buffer_removal_time_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.allow_intrabc, settings, "uint32_t: 1", "allow_intrabc", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.frame_refs_short_signaling, settings, "uint32_t: 1", "frame_refs_short_signaling", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.allow_high_precision_mv, settings, "uint32_t: 1", "allow_high_precision_mv", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.is_motion_mode_switchable, settings, "uint32_t: 1", "is_motion_mode_switchable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.use_ref_frame_mvs, settings, "uint32_t: 1", "use_ref_frame_mvs", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.disable_frame_end_update_cdf, settings, "uint32_t: 1", "disable_frame_end_update_cdf", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.allow_warped_motion, settings, "uint32_t: 1", "allow_warped_motion", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reduced_tx_set, settings, "uint32_t: 1", "reduced_tx_set", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reference_select, settings, "uint32_t: 1", "reference_select", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.skip_mode_present, settings, "uint32_t: 1", "skip_mode_present", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.delta_q_present, settings, "uint32_t: 1", "delta_q_present", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.delta_lf_present, settings, "uint32_t: 1", "delta_lf_present", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.delta_lf_multi, settings, "uint32_t: 1", "delta_lf_multi", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.segmentation_enabled, settings, "uint32_t: 1", "segmentation_enabled", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.segmentation_update_map, settings, "uint32_t: 1", "segmentation_update_map", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.segmentation_temporal_update, settings, "uint32_t: 1", "segmentation_temporal_update", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.segmentation_update_data, settings, "uint32_t: 1", "segmentation_update_data", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.UsesLr, settings, "uint32_t: 1", "UsesLr", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.usesChromaLr, settings, "uint32_t: 1", "usesChromaLr", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.apply_grain, settings, "uint32_t: 1", "apply_grain", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved, settings, "uint32_t: 3", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoDecodeAV1PictureInfo(const StdVideoDecodeAV1PictureInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_StdVideoDecodeAV1PictureInfoFlags(object.flags, settings, "StdVideoDecodeAV1PictureInfoFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoAV1FrameType(object.frame_type, settings, "StdVideoAV1FrameType", "frame_type", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.current_frame_id, settings, "uint32_t", "current_frame_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.OrderHint, settings, "uint8_t", "OrderHint", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.primary_ref_frame, settings, "uint8_t", "primary_ref_frame", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.refresh_frame_flags, settings, "uint8_t", "refresh_frame_flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved1, settings, "uint8_t", "reserved1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoAV1InterpolationFilter(object.interpolation_filter, settings, "StdVideoAV1InterpolationFilter", "interpolation_filter", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoAV1TxMode(object.TxMode, settings, "StdVideoAV1TxMode", "TxMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.delta_q_res, settings, "uint8_t", "delta_q_res", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.delta_lf_res, settings, "uint8_t", "delta_lf_res", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.SkipModeFrame, STD_VIDEO_AV1_SKIP_MODE_FRAMES, settings, "uint8_t[STD_VIDEO_AV1_SKIP_MODE_FRAMES]", "SkipModeFrame", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.coded_denom, settings, "uint8_t", "coded_denom", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.reserved2, 3, settings, "uint8_t[3]", "reserved2", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.OrderHints, STD_VIDEO_AV1_NUM_REF_FRAMES, settings, "uint8_t[STD_VIDEO_AV1_NUM_REF_FRAMES]", "OrderHints", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.expectedFrameId, STD_VIDEO_AV1_NUM_REF_FRAMES, settings, "uint32_t[STD_VIDEO_AV1_NUM_REF_FRAMES]", "expectedFrameId", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_pointer(object.pTileInfo, settings, "const StdVideoAV1TileInfo*", "pTileInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1TileInfo); + dump_separate_members(settings); + dump_pointer(object.pQuantization, settings, "const StdVideoAV1Quantization*", "pQuantization", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1Quantization); + dump_separate_members(settings); + dump_pointer(object.pSegmentation, settings, "const StdVideoAV1Segmentation*", "pSegmentation", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1Segmentation); + dump_separate_members(settings); + dump_pointer(object.pLoopFilter, settings, "const StdVideoAV1LoopFilter*", "pLoopFilter", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1LoopFilter); + dump_separate_members(settings); + dump_pointer(object.pCDEF, settings, "const StdVideoAV1CDEF*", "pCDEF", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1CDEF); + dump_separate_members(settings); + dump_pointer(object.pLoopRestoration, settings, "const StdVideoAV1LoopRestoration*", "pLoopRestoration", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1LoopRestoration); + dump_separate_members(settings); + dump_pointer(object.pGlobalMotion, settings, "const StdVideoAV1GlobalMotion*", "pGlobalMotion", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1GlobalMotion); + dump_separate_members(settings); + dump_pointer(object.pFilmGrain, settings, "const StdVideoAV1FilmGrain*", "pFilmGrain", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1FilmGrain); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoDecodeAV1ReferenceInfoFlags(const StdVideoDecodeAV1ReferenceInfoFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.disable_frame_end_update_cdf, settings, "uint32_t: 1", "disable_frame_end_update_cdf", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.segmentation_enabled, settings, "uint32_t: 1", "segmentation_enabled", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved, settings, "uint32_t: 30", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoDecodeAV1ReferenceInfo(const StdVideoDecodeAV1ReferenceInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_StdVideoDecodeAV1ReferenceInfoFlags(object.flags, settings, "StdVideoDecodeAV1ReferenceInfoFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.frame_type, settings, "uint8_t", "frame_type", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.RefFrameSignBias, settings, "uint8_t", "RefFrameSignBias", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.OrderHint, settings, "uint8_t", "OrderHint", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.SavedOrderHints, STD_VIDEO_AV1_NUM_REF_FRAMES, settings, "uint8_t[STD_VIDEO_AV1_NUM_REF_FRAMES]", "SavedOrderHints", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoEncodeAV1DecoderModelInfo(const StdVideoEncodeAV1DecoderModelInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.buffer_delay_length_minus_1, settings, "uint8_t", "buffer_delay_length_minus_1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.buffer_removal_time_length_minus_1, settings, "uint8_t", "buffer_removal_time_length_minus_1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.frame_presentation_time_length_minus_1, settings, "uint8_t", "frame_presentation_time_length_minus_1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved1, settings, "uint8_t", "reserved1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.num_units_in_decoding_tick, settings, "uint32_t", "num_units_in_decoding_tick", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoEncodeAV1ExtensionHeader(const StdVideoEncodeAV1ExtensionHeader& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.temporal_id, settings, "uint8_t", "temporal_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.spatial_id, settings, "uint8_t", "spatial_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoEncodeAV1OperatingPointInfoFlags(const StdVideoEncodeAV1OperatingPointInfoFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.decoder_model_present_for_this_op, settings, "uint32_t: 1", "decoder_model_present_for_this_op", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.low_delay_mode_flag, settings, "uint32_t: 1", "low_delay_mode_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.initial_display_delay_present_for_this_op, settings, "uint32_t: 1", "initial_display_delay_present_for_this_op", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved, settings, "uint32_t: 29", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoEncodeAV1OperatingPointInfo(const StdVideoEncodeAV1OperatingPointInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_StdVideoEncodeAV1OperatingPointInfoFlags(object.flags, settings, "StdVideoEncodeAV1OperatingPointInfoFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.operating_point_idc, settings, "uint16_t", "operating_point_idc", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.seq_level_idx, settings, "uint8_t", "seq_level_idx", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.seq_tier, settings, "uint8_t", "seq_tier", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.decoder_buffer_delay, settings, "uint32_t", "decoder_buffer_delay", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.encoder_buffer_delay, settings, "uint32_t", "encoder_buffer_delay", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.initial_display_delay_minus_1, settings, "uint8_t", "initial_display_delay_minus_1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoEncodeAV1PictureInfoFlags(const StdVideoEncodeAV1PictureInfoFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.error_resilient_mode, settings, "uint32_t: 1", "error_resilient_mode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.disable_cdf_update, settings, "uint32_t: 1", "disable_cdf_update", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.use_superres, settings, "uint32_t: 1", "use_superres", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.render_and_frame_size_different, settings, "uint32_t: 1", "render_and_frame_size_different", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.allow_screen_content_tools, settings, "uint32_t: 1", "allow_screen_content_tools", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.is_filter_switchable, settings, "uint32_t: 1", "is_filter_switchable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.force_integer_mv, settings, "uint32_t: 1", "force_integer_mv", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.frame_size_override_flag, settings, "uint32_t: 1", "frame_size_override_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.buffer_removal_time_present_flag, settings, "uint32_t: 1", "buffer_removal_time_present_flag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.allow_intrabc, settings, "uint32_t: 1", "allow_intrabc", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.frame_refs_short_signaling, settings, "uint32_t: 1", "frame_refs_short_signaling", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.allow_high_precision_mv, settings, "uint32_t: 1", "allow_high_precision_mv", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.is_motion_mode_switchable, settings, "uint32_t: 1", "is_motion_mode_switchable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.use_ref_frame_mvs, settings, "uint32_t: 1", "use_ref_frame_mvs", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.disable_frame_end_update_cdf, settings, "uint32_t: 1", "disable_frame_end_update_cdf", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.allow_warped_motion, settings, "uint32_t: 1", "allow_warped_motion", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reduced_tx_set, settings, "uint32_t: 1", "reduced_tx_set", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.skip_mode_present, settings, "uint32_t: 1", "skip_mode_present", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.delta_q_present, settings, "uint32_t: 1", "delta_q_present", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.delta_lf_present, settings, "uint32_t: 1", "delta_lf_present", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.delta_lf_multi, settings, "uint32_t: 1", "delta_lf_multi", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.segmentation_enabled, settings, "uint32_t: 1", "segmentation_enabled", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.segmentation_update_map, settings, "uint32_t: 1", "segmentation_update_map", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.segmentation_temporal_update, settings, "uint32_t: 1", "segmentation_temporal_update", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.segmentation_update_data, settings, "uint32_t: 1", "segmentation_update_data", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.UsesLr, settings, "uint32_t: 1", "UsesLr", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.usesChromaLr, settings, "uint32_t: 1", "usesChromaLr", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.show_frame, settings, "uint32_t: 1", "show_frame", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.showable_frame, settings, "uint32_t: 1", "showable_frame", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved, settings, "uint32_t: 3", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoEncodeAV1PictureInfo(const StdVideoEncodeAV1PictureInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_StdVideoEncodeAV1PictureInfoFlags(object.flags, settings, "StdVideoEncodeAV1PictureInfoFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoAV1FrameType(object.frame_type, settings, "StdVideoAV1FrameType", "frame_type", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.frame_presentation_time, settings, "uint32_t", "frame_presentation_time", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.current_frame_id, settings, "uint32_t", "current_frame_id", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.order_hint, settings, "uint8_t", "order_hint", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.primary_ref_frame, settings, "uint8_t", "primary_ref_frame", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.refresh_frame_flags, settings, "uint8_t", "refresh_frame_flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.coded_denom, settings, "uint8_t", "coded_denom", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.render_width_minus_1, settings, "uint16_t", "render_width_minus_1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.render_height_minus_1, settings, "uint16_t", "render_height_minus_1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoAV1InterpolationFilter(object.interpolation_filter, settings, "StdVideoAV1InterpolationFilter", "interpolation_filter", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoAV1TxMode(object.TxMode, settings, "StdVideoAV1TxMode", "TxMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.delta_q_res, settings, "uint8_t", "delta_q_res", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.delta_lf_res, settings, "uint8_t", "delta_lf_res", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.ref_order_hint, STD_VIDEO_AV1_NUM_REF_FRAMES, settings, "uint8_t[STD_VIDEO_AV1_NUM_REF_FRAMES]", "ref_order_hint", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.ref_frame_idx, STD_VIDEO_AV1_REFS_PER_FRAME, settings, "int8_t[STD_VIDEO_AV1_REFS_PER_FRAME]", "ref_frame_idx", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.reserved1, 3, settings, "uint8_t[3]", "reserved1", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.delta_frame_id_minus_1, STD_VIDEO_AV1_REFS_PER_FRAME, settings, "uint32_t[STD_VIDEO_AV1_REFS_PER_FRAME]", "delta_frame_id_minus_1", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_pointer(object.pTileInfo, settings, "const StdVideoAV1TileInfo*", "pTileInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1TileInfo); + dump_separate_members(settings); + dump_pointer(object.pQuantization, settings, "const StdVideoAV1Quantization*", "pQuantization", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1Quantization); + dump_separate_members(settings); + dump_pointer(object.pSegmentation, settings, "const StdVideoAV1Segmentation*", "pSegmentation", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1Segmentation); + dump_separate_members(settings); + dump_pointer(object.pLoopFilter, settings, "const StdVideoAV1LoopFilter*", "pLoopFilter", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1LoopFilter); + dump_separate_members(settings); + dump_pointer(object.pCDEF, settings, "const StdVideoAV1CDEF*", "pCDEF", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1CDEF); + dump_separate_members(settings); + dump_pointer(object.pLoopRestoration, settings, "const StdVideoAV1LoopRestoration*", "pLoopRestoration", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1LoopRestoration); + dump_separate_members(settings); + dump_pointer(object.pGlobalMotion, settings, "const StdVideoAV1GlobalMotion*", "pGlobalMotion", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1GlobalMotion); + dump_separate_members(settings); + dump_pointer(object.pExtensionHeader, settings, "const StdVideoEncodeAV1ExtensionHeader*", "pExtensionHeader", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeAV1ExtensionHeader); + dump_separate_members(settings); + dump_pointer(object.pBufferRemovalTimes, settings, "const uint32_t*", "pBufferRemovalTimes", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoEncodeAV1ReferenceInfoFlags(const StdVideoEncodeAV1ReferenceInfoFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.disable_frame_end_update_cdf, settings, "uint32_t: 1", "disable_frame_end_update_cdf", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.segmentation_enabled, settings, "uint32_t: 1", "segmentation_enabled", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved, settings, "uint32_t: 30", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoEncodeAV1ReferenceInfo(const StdVideoEncodeAV1ReferenceInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_StdVideoEncodeAV1ReferenceInfoFlags(object.flags, settings, "StdVideoEncodeAV1ReferenceInfoFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.RefFrameId, settings, "uint32_t", "RefFrameId", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoAV1FrameType(object.frame_type, settings, "StdVideoAV1FrameType", "frame_type", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.OrderHint, settings, "uint8_t", "OrderHint", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.reserved1, 3, settings, "uint8_t[3]", "reserved1", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_pointer(object.pExtensionHeader, settings, "const StdVideoEncodeAV1ExtensionHeader*", "pExtensionHeader", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeAV1ExtensionHeader); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoVP9ColorConfigFlags(const StdVideoVP9ColorConfigFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.color_range, settings, "uint32_t: 1", "color_range", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved, settings, "uint32_t: 31", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoVP9ColorConfig(const StdVideoVP9ColorConfig& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_StdVideoVP9ColorConfigFlags(object.flags, settings, "StdVideoVP9ColorConfigFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.BitDepth, settings, "uint8_t", "BitDepth", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.subsampling_x, settings, "uint8_t", "subsampling_x", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.subsampling_y, settings, "uint8_t", "subsampling_y", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved1, settings, "uint8_t", "reserved1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoVP9ColorSpace(object.color_space, settings, "StdVideoVP9ColorSpace", "color_space", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoVP9LoopFilterFlags(const StdVideoVP9LoopFilterFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.loop_filter_delta_enabled, settings, "uint32_t: 1", "loop_filter_delta_enabled", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.loop_filter_delta_update, settings, "uint32_t: 1", "loop_filter_delta_update", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved, settings, "uint32_t: 30", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoVP9LoopFilter(const StdVideoVP9LoopFilter& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_StdVideoVP9LoopFilterFlags(object.flags, settings, "StdVideoVP9LoopFilterFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.loop_filter_level, settings, "uint8_t", "loop_filter_level", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.loop_filter_sharpness, settings, "uint8_t", "loop_filter_sharpness", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.update_ref_delta, settings, "uint8_t", "update_ref_delta", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.loop_filter_ref_deltas, STD_VIDEO_VP9_MAX_REF_FRAMES, settings, "int8_t[STD_VIDEO_VP9_MAX_REF_FRAMES]", "loop_filter_ref_deltas", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.update_mode_delta, settings, "uint8_t", "update_mode_delta", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.loop_filter_mode_deltas, STD_VIDEO_VP9_LOOP_FILTER_ADJUSTMENTS, settings, "int8_t[STD_VIDEO_VP9_LOOP_FILTER_ADJUSTMENTS]", "loop_filter_mode_deltas", "int8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoVP9SegmentationFlags(const StdVideoVP9SegmentationFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.segmentation_update_map, settings, "uint32_t: 1", "segmentation_update_map", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.segmentation_temporal_update, settings, "uint32_t: 1", "segmentation_temporal_update", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.segmentation_update_data, settings, "uint32_t: 1", "segmentation_update_data", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.segmentation_abs_or_delta_update, settings, "uint32_t: 1", "segmentation_abs_or_delta_update", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved, settings, "uint32_t: 28", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoVP9Segmentation(const StdVideoVP9Segmentation& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_StdVideoVP9SegmentationFlags(object.flags, settings, "StdVideoVP9SegmentationFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.segmentation_tree_probs, STD_VIDEO_VP9_MAX_SEGMENTATION_TREE_PROBS, settings, "uint8_t[STD_VIDEO_VP9_MAX_SEGMENTATION_TREE_PROBS]", "segmentation_tree_probs", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.segmentation_pred_prob, STD_VIDEO_VP9_MAX_SEGMENTATION_PRED_PROB, settings, "uint8_t[STD_VIDEO_VP9_MAX_SEGMENTATION_PRED_PROB]", "segmentation_pred_prob", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.FeatureEnabled, STD_VIDEO_VP9_MAX_SEGMENTS, settings, "uint8_t[STD_VIDEO_VP9_MAX_SEGMENTS]", "FeatureEnabled", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_double_array(object.FeatureData, STD_VIDEO_VP9_MAX_SEGMENTS, STD_VIDEO_VP9_SEG_LVL_MAX, settings, "int16_t[STD_VIDEO_VP9_MAX_SEGMENTS][STD_VIDEO_VP9_SEG_LVL_MAX]", "FeatureData", "int16_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoDecodeVP9PictureInfoFlags(const StdVideoDecodeVP9PictureInfoFlags& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.error_resilient_mode, settings, "uint32_t: 1", "error_resilient_mode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.intra_only, settings, "uint32_t: 1", "intra_only", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.allow_high_precision_mv, settings, "uint32_t: 1", "allow_high_precision_mv", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.refresh_frame_context, settings, "uint32_t: 1", "refresh_frame_context", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.frame_parallel_decoding_mode, settings, "uint32_t: 1", "frame_parallel_decoding_mode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.segmentation_enabled, settings, "uint32_t: 1", "segmentation_enabled", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.show_frame, settings, "uint32_t: 1", "show_frame", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.UsePrevFrameMvs, settings, "uint32_t: 1", "UsePrevFrameMvs", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved, settings, "uint32_t: 24", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_StdVideoDecodeVP9PictureInfo(const StdVideoDecodeVP9PictureInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_StdVideoDecodeVP9PictureInfoFlags(object.flags, settings, "StdVideoDecodeVP9PictureInfoFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoVP9Profile(object.profile, settings, "StdVideoVP9Profile", "profile", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoVP9FrameType(object.frame_type, settings, "StdVideoVP9FrameType", "frame_type", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.frame_context_idx, settings, "uint8_t", "frame_context_idx", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reset_frame_context, settings, "uint8_t", "reset_frame_context", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.refresh_frame_flags, settings, "uint8_t", "refresh_frame_flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.ref_frame_sign_bias_mask, settings, "uint8_t", "ref_frame_sign_bias_mask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoVP9InterpolationFilter(object.interpolation_filter, settings, "StdVideoVP9InterpolationFilter", "interpolation_filter", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.base_q_idx, settings, "uint8_t", "base_q_idx", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.delta_q_y_dc, settings, "int8_t", "delta_q_y_dc", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.delta_q_uv_dc, settings, "int8_t", "delta_q_uv_dc", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.delta_q_uv_ac, settings, "int8_t", "delta_q_uv_ac", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tile_cols_log2, settings, "uint8_t", "tile_cols_log2", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tile_rows_log2, settings, "uint8_t", "tile_rows_log2", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.reserved1, 3, settings, "uint16_t[3]", "reserved1", "uint16_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_pointer(object.pColorConfig, settings, "const StdVideoVP9ColorConfig*", "pColorConfig", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoVP9ColorConfig); + dump_separate_members(settings); + dump_pointer(object.pLoopFilter, settings, "const StdVideoVP9LoopFilter*", "pLoopFilter", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoVP9LoopFilter); + dump_separate_members(settings); + dump_pointer(object.pSegmentation, settings, "const StdVideoVP9Segmentation*", "pSegmentation", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoVP9Segmentation); + dump_end(settings, OutputConstruct::api_struct, indents); +} + +//====================== Struct and Union Implementations =====================// + +template +void dump_VkExtent2D(const VkExtent2D& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.width, settings, "uint32_t", "width", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.height, settings, "uint32_t", "height", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkExtent3D(const VkExtent3D& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.width, settings, "uint32_t", "width", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.height, settings, "uint32_t", "height", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.depth, settings, "uint32_t", "depth", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkOffset2D(const VkOffset2D& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.x, settings, "int32_t", "x", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.y, settings, "int32_t", "y", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkOffset3D(const VkOffset3D& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.x, settings, "int32_t", "x", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.y, settings, "int32_t", "y", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.z, settings, "int32_t", "z", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkRect2D(const VkRect2D& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkOffset2D(object.offset, settings, "VkOffset2D", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.extent, settings, "VkExtent2D", "extent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBaseInStructure(const VkBaseInStructure& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pNext, settings, "const struct VkBaseInStructure*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkBaseInStructure); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBaseOutStructure(const VkBaseOutStructure& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pNext, settings, "struct VkBaseOutStructure*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkBaseOutStructure); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBufferMemoryBarrier(const VkBufferMemoryBarrier& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccessFlags(object.srcAccessMask, settings, "VkAccessFlags", "srcAccessMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccessFlags(object.dstAccessMask, settings, "VkAccessFlags", "dstAccessMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.srcQueueFamilyIndex, settings, "uint32_t", "srcQueueFamilyIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dstQueueFamilyIndex, settings, "uint32_t", "dstQueueFamilyIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBuffer(object.buffer, settings, "VkBuffer", "buffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.offset, settings, "VkDeviceSize", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImageSubresourceRange(const VkImageSubresourceRange& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkImageAspectFlags(object.aspectMask, settings, "VkImageAspectFlags", "aspectMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.baseMipLevel, settings, "uint32_t", "baseMipLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.levelCount, settings, "uint32_t", "levelCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.baseArrayLayer, settings, "uint32_t", "baseArrayLayer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.layerCount, settings, "uint32_t", "layerCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImageMemoryBarrier(const VkImageMemoryBarrier& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccessFlags(object.srcAccessMask, settings, "VkAccessFlags", "srcAccessMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccessFlags(object.dstAccessMask, settings, "VkAccessFlags", "dstAccessMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(object.oldLayout, settings, "VkImageLayout", "oldLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(object.newLayout, settings, "VkImageLayout", "newLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.srcQueueFamilyIndex, settings, "uint32_t", "srcQueueFamilyIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dstQueueFamilyIndex, settings, "uint32_t", "dstQueueFamilyIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImage(object.image, settings, "VkImage", "image", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageSubresourceRange(object.subresourceRange, settings, "VkImageSubresourceRange", "subresourceRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMemoryBarrier(const VkMemoryBarrier& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccessFlags(object.srcAccessMask, settings, "VkAccessFlags", "srcAccessMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccessFlags(object.dstAccessMask, settings, "VkAccessFlags", "dstAccessMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAllocationCallbacks(const VkAllocationCallbacks& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.pUserData, settings, "void*", "pUserData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_PFN_vkAllocationFunction(object.pfnAllocation, settings, "PFN_vkAllocationFunction", "pfnAllocation", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_PFN_vkReallocationFunction(object.pfnReallocation, settings, "PFN_vkReallocationFunction", "pfnReallocation", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_PFN_vkFreeFunction(object.pfnFree, settings, "PFN_vkFreeFunction", "pfnFree", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_PFN_vkInternalAllocationNotification(object.pfnInternalAllocation, settings, "PFN_vkInternalAllocationNotification", "pfnInternalAllocation", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_PFN_vkInternalFreeNotification(object.pfnInternalFree, settings, "PFN_vkInternalFreeNotification", "pfnInternalFree", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkApplicationInfo(const VkApplicationInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_char(object.pApplicationName, settings, "const char*", "pApplicationName", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.applicationVersion, settings, "uint32_t", "applicationVersion", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_char(object.pEngineName, settings, "const char*", "pEngineName", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.engineVersion, settings, "uint32_t", "engineVersion", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_api_version(object.apiVersion, settings, "uint32_t", "apiVersion", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkFormatProperties(const VkFormatProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkFormatFeatureFlags(object.linearTilingFeatures, settings, "VkFormatFeatureFlags", "linearTilingFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormatFeatureFlags(object.optimalTilingFeatures, settings, "VkFormatFeatureFlags", "optimalTilingFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormatFeatureFlags(object.bufferFeatures, settings, "VkFormatFeatureFlags", "bufferFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImageFormatProperties(const VkImageFormatProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkExtent3D(object.maxExtent, settings, "VkExtent3D", "maxExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxMipLevels, settings, "uint32_t", "maxMipLevels", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxArrayLayers, settings, "uint32_t", "maxArrayLayers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSampleCountFlags(object.sampleCounts, settings, "VkSampleCountFlags", "sampleCounts", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxResourceSize, settings, "VkDeviceSize", "maxResourceSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkInstanceCreateInfo(const VkInstanceCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkInstanceCreateFlags(object.flags, settings, "VkInstanceCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pApplicationInfo, settings, "const VkApplicationInfo*", "pApplicationInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkApplicationInfo); + dump_separate_members(settings); + dump_type(object.enabledLayerCount, settings, "uint32_t", "enabledLayerCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.ppEnabledLayerNames, object.enabledLayerCount, settings, "const char* const*", "ppEnabledLayerNames", "const char*", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_char); + dump_separate_members(settings); + dump_type(object.enabledExtensionCount, settings, "uint32_t", "enabledExtensionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.ppEnabledExtensionNames, object.enabledExtensionCount, settings, "const char* const*", "ppEnabledExtensionNames", "const char*", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_char); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMemoryHeap(const VkMemoryHeap& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkMemoryHeapFlags(object.flags, settings, "VkMemoryHeapFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMemoryType(const VkMemoryType& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkMemoryPropertyFlags(object.propertyFlags, settings, "VkMemoryPropertyFlags", "propertyFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.heapIndex, settings, "uint32_t", "heapIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceFeatures(const VkPhysicalDeviceFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.robustBufferAccess, settings, "VkBool32", "robustBufferAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.fullDrawIndexUint32, settings, "VkBool32", "fullDrawIndexUint32", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.imageCubeArray, settings, "VkBool32", "imageCubeArray", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.independentBlend, settings, "VkBool32", "independentBlend", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.geometryShader, settings, "VkBool32", "geometryShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tessellationShader, settings, "VkBool32", "tessellationShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sampleRateShading, settings, "VkBool32", "sampleRateShading", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dualSrcBlend, settings, "VkBool32", "dualSrcBlend", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.logicOp, settings, "VkBool32", "logicOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.multiDrawIndirect, settings, "VkBool32", "multiDrawIndirect", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.drawIndirectFirstInstance, settings, "VkBool32", "drawIndirectFirstInstance", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.depthClamp, settings, "VkBool32", "depthClamp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.depthBiasClamp, settings, "VkBool32", "depthBiasClamp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.fillModeNonSolid, settings, "VkBool32", "fillModeNonSolid", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.depthBounds, settings, "VkBool32", "depthBounds", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.wideLines, settings, "VkBool32", "wideLines", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.largePoints, settings, "VkBool32", "largePoints", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.alphaToOne, settings, "VkBool32", "alphaToOne", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.multiViewport, settings, "VkBool32", "multiViewport", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.samplerAnisotropy, settings, "VkBool32", "samplerAnisotropy", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.textureCompressionETC2, settings, "VkBool32", "textureCompressionETC2", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.textureCompressionASTC_LDR, settings, "VkBool32", "textureCompressionASTC_LDR", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.textureCompressionBC, settings, "VkBool32", "textureCompressionBC", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.occlusionQueryPrecise, settings, "VkBool32", "occlusionQueryPrecise", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pipelineStatisticsQuery, settings, "VkBool32", "pipelineStatisticsQuery", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vertexPipelineStoresAndAtomics, settings, "VkBool32", "vertexPipelineStoresAndAtomics", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.fragmentStoresAndAtomics, settings, "VkBool32", "fragmentStoresAndAtomics", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderTessellationAndGeometryPointSize, settings, "VkBool32", "shaderTessellationAndGeometryPointSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderImageGatherExtended, settings, "VkBool32", "shaderImageGatherExtended", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderStorageImageExtendedFormats, settings, "VkBool32", "shaderStorageImageExtendedFormats", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderStorageImageMultisample, settings, "VkBool32", "shaderStorageImageMultisample", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderStorageImageReadWithoutFormat, settings, "VkBool32", "shaderStorageImageReadWithoutFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderStorageImageWriteWithoutFormat, settings, "VkBool32", "shaderStorageImageWriteWithoutFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderUniformBufferArrayDynamicIndexing, settings, "VkBool32", "shaderUniformBufferArrayDynamicIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderSampledImageArrayDynamicIndexing, settings, "VkBool32", "shaderSampledImageArrayDynamicIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderStorageBufferArrayDynamicIndexing, settings, "VkBool32", "shaderStorageBufferArrayDynamicIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderStorageImageArrayDynamicIndexing, settings, "VkBool32", "shaderStorageImageArrayDynamicIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderClipDistance, settings, "VkBool32", "shaderClipDistance", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderCullDistance, settings, "VkBool32", "shaderCullDistance", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderFloat64, settings, "VkBool32", "shaderFloat64", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderInt64, settings, "VkBool32", "shaderInt64", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderInt16, settings, "VkBool32", "shaderInt16", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderResourceResidency, settings, "VkBool32", "shaderResourceResidency", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderResourceMinLod, settings, "VkBool32", "shaderResourceMinLod", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sparseBinding, settings, "VkBool32", "sparseBinding", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sparseResidencyBuffer, settings, "VkBool32", "sparseResidencyBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sparseResidencyImage2D, settings, "VkBool32", "sparseResidencyImage2D", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sparseResidencyImage3D, settings, "VkBool32", "sparseResidencyImage3D", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sparseResidency2Samples, settings, "VkBool32", "sparseResidency2Samples", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sparseResidency4Samples, settings, "VkBool32", "sparseResidency4Samples", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sparseResidency8Samples, settings, "VkBool32", "sparseResidency8Samples", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sparseResidency16Samples, settings, "VkBool32", "sparseResidency16Samples", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sparseResidencyAliased, settings, "VkBool32", "sparseResidencyAliased", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.variableMultisampleRate, settings, "VkBool32", "variableMultisampleRate", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.inheritedQueries, settings, "VkBool32", "inheritedQueries", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceLimits(const VkPhysicalDeviceLimits& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.maxImageDimension1D, settings, "uint32_t", "maxImageDimension1D", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxImageDimension2D, settings, "uint32_t", "maxImageDimension2D", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxImageDimension3D, settings, "uint32_t", "maxImageDimension3D", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxImageDimensionCube, settings, "uint32_t", "maxImageDimensionCube", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxImageArrayLayers, settings, "uint32_t", "maxImageArrayLayers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxTexelBufferElements, settings, "uint32_t", "maxTexelBufferElements", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxUniformBufferRange, settings, "uint32_t", "maxUniformBufferRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxStorageBufferRange, settings, "uint32_t", "maxStorageBufferRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPushConstantsSize, settings, "uint32_t", "maxPushConstantsSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxMemoryAllocationCount, settings, "uint32_t", "maxMemoryAllocationCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxSamplerAllocationCount, settings, "uint32_t", "maxSamplerAllocationCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bufferImageGranularity, settings, "VkDeviceSize", "bufferImageGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sparseAddressSpaceSize, settings, "VkDeviceSize", "sparseAddressSpaceSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxBoundDescriptorSets, settings, "uint32_t", "maxBoundDescriptorSets", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPerStageDescriptorSamplers, settings, "uint32_t", "maxPerStageDescriptorSamplers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPerStageDescriptorUniformBuffers, settings, "uint32_t", "maxPerStageDescriptorUniformBuffers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPerStageDescriptorStorageBuffers, settings, "uint32_t", "maxPerStageDescriptorStorageBuffers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPerStageDescriptorSampledImages, settings, "uint32_t", "maxPerStageDescriptorSampledImages", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPerStageDescriptorStorageImages, settings, "uint32_t", "maxPerStageDescriptorStorageImages", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPerStageDescriptorInputAttachments, settings, "uint32_t", "maxPerStageDescriptorInputAttachments", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPerStageResources, settings, "uint32_t", "maxPerStageResources", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDescriptorSetSamplers, settings, "uint32_t", "maxDescriptorSetSamplers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDescriptorSetUniformBuffers, settings, "uint32_t", "maxDescriptorSetUniformBuffers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDescriptorSetUniformBuffersDynamic, settings, "uint32_t", "maxDescriptorSetUniformBuffersDynamic", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDescriptorSetStorageBuffers, settings, "uint32_t", "maxDescriptorSetStorageBuffers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDescriptorSetStorageBuffersDynamic, settings, "uint32_t", "maxDescriptorSetStorageBuffersDynamic", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDescriptorSetSampledImages, settings, "uint32_t", "maxDescriptorSetSampledImages", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDescriptorSetStorageImages, settings, "uint32_t", "maxDescriptorSetStorageImages", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDescriptorSetInputAttachments, settings, "uint32_t", "maxDescriptorSetInputAttachments", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxVertexInputAttributes, settings, "uint32_t", "maxVertexInputAttributes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxVertexInputBindings, settings, "uint32_t", "maxVertexInputBindings", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxVertexInputAttributeOffset, settings, "uint32_t", "maxVertexInputAttributeOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxVertexInputBindingStride, settings, "uint32_t", "maxVertexInputBindingStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxVertexOutputComponents, settings, "uint32_t", "maxVertexOutputComponents", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxTessellationGenerationLevel, settings, "uint32_t", "maxTessellationGenerationLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxTessellationPatchSize, settings, "uint32_t", "maxTessellationPatchSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxTessellationControlPerVertexInputComponents, settings, "uint32_t", "maxTessellationControlPerVertexInputComponents", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxTessellationControlPerVertexOutputComponents, settings, "uint32_t", "maxTessellationControlPerVertexOutputComponents", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxTessellationControlPerPatchOutputComponents, settings, "uint32_t", "maxTessellationControlPerPatchOutputComponents", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxTessellationControlTotalOutputComponents, settings, "uint32_t", "maxTessellationControlTotalOutputComponents", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxTessellationEvaluationInputComponents, settings, "uint32_t", "maxTessellationEvaluationInputComponents", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxTessellationEvaluationOutputComponents, settings, "uint32_t", "maxTessellationEvaluationOutputComponents", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxGeometryShaderInvocations, settings, "uint32_t", "maxGeometryShaderInvocations", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxGeometryInputComponents, settings, "uint32_t", "maxGeometryInputComponents", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxGeometryOutputComponents, settings, "uint32_t", "maxGeometryOutputComponents", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxGeometryOutputVertices, settings, "uint32_t", "maxGeometryOutputVertices", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxGeometryTotalOutputComponents, settings, "uint32_t", "maxGeometryTotalOutputComponents", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxFragmentInputComponents, settings, "uint32_t", "maxFragmentInputComponents", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxFragmentOutputAttachments, settings, "uint32_t", "maxFragmentOutputAttachments", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxFragmentDualSrcAttachments, settings, "uint32_t", "maxFragmentDualSrcAttachments", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxFragmentCombinedOutputResources, settings, "uint32_t", "maxFragmentCombinedOutputResources", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxComputeSharedMemorySize, settings, "uint32_t", "maxComputeSharedMemorySize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.maxComputeWorkGroupCount, 3, settings, "uint32_t[3]", "maxComputeWorkGroupCount", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.maxComputeWorkGroupInvocations, settings, "uint32_t", "maxComputeWorkGroupInvocations", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.maxComputeWorkGroupSize, 3, settings, "uint32_t[3]", "maxComputeWorkGroupSize", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.subPixelPrecisionBits, settings, "uint32_t", "subPixelPrecisionBits", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.subTexelPrecisionBits, settings, "uint32_t", "subTexelPrecisionBits", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.mipmapPrecisionBits, settings, "uint32_t", "mipmapPrecisionBits", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDrawIndexedIndexValue, settings, "uint32_t", "maxDrawIndexedIndexValue", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDrawIndirectCount, settings, "uint32_t", "maxDrawIndirectCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxSamplerLodBias, settings, "float", "maxSamplerLodBias", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxSamplerAnisotropy, settings, "float", "maxSamplerAnisotropy", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxViewports, settings, "uint32_t", "maxViewports", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.maxViewportDimensions, 2, settings, "uint32_t[2]", "maxViewportDimensions", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.viewportBoundsRange, 2, settings, "float[2]", "viewportBoundsRange", "float", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.viewportSubPixelBits, settings, "uint32_t", "viewportSubPixelBits", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minMemoryMapAlignment, settings, "size_t", "minMemoryMapAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minTexelBufferOffsetAlignment, settings, "VkDeviceSize", "minTexelBufferOffsetAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minUniformBufferOffsetAlignment, settings, "VkDeviceSize", "minUniformBufferOffsetAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minStorageBufferOffsetAlignment, settings, "VkDeviceSize", "minStorageBufferOffsetAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minTexelOffset, settings, "int32_t", "minTexelOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxTexelOffset, settings, "uint32_t", "maxTexelOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minTexelGatherOffset, settings, "int32_t", "minTexelGatherOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxTexelGatherOffset, settings, "uint32_t", "maxTexelGatherOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minInterpolationOffset, settings, "float", "minInterpolationOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxInterpolationOffset, settings, "float", "maxInterpolationOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.subPixelInterpolationOffsetBits, settings, "uint32_t", "subPixelInterpolationOffsetBits", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxFramebufferWidth, settings, "uint32_t", "maxFramebufferWidth", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxFramebufferHeight, settings, "uint32_t", "maxFramebufferHeight", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxFramebufferLayers, settings, "uint32_t", "maxFramebufferLayers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSampleCountFlags(object.framebufferColorSampleCounts, settings, "VkSampleCountFlags", "framebufferColorSampleCounts", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSampleCountFlags(object.framebufferDepthSampleCounts, settings, "VkSampleCountFlags", "framebufferDepthSampleCounts", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSampleCountFlags(object.framebufferStencilSampleCounts, settings, "VkSampleCountFlags", "framebufferStencilSampleCounts", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSampleCountFlags(object.framebufferNoAttachmentsSampleCounts, settings, "VkSampleCountFlags", "framebufferNoAttachmentsSampleCounts", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxColorAttachments, settings, "uint32_t", "maxColorAttachments", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSampleCountFlags(object.sampledImageColorSampleCounts, settings, "VkSampleCountFlags", "sampledImageColorSampleCounts", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSampleCountFlags(object.sampledImageIntegerSampleCounts, settings, "VkSampleCountFlags", "sampledImageIntegerSampleCounts", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSampleCountFlags(object.sampledImageDepthSampleCounts, settings, "VkSampleCountFlags", "sampledImageDepthSampleCounts", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSampleCountFlags(object.sampledImageStencilSampleCounts, settings, "VkSampleCountFlags", "sampledImageStencilSampleCounts", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSampleCountFlags(object.storageImageSampleCounts, settings, "VkSampleCountFlags", "storageImageSampleCounts", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxSampleMaskWords, settings, "uint32_t", "maxSampleMaskWords", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.timestampComputeAndGraphics, settings, "VkBool32", "timestampComputeAndGraphics", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.timestampPeriod, settings, "float", "timestampPeriod", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxClipDistances, settings, "uint32_t", "maxClipDistances", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxCullDistances, settings, "uint32_t", "maxCullDistances", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxCombinedClipAndCullDistances, settings, "uint32_t", "maxCombinedClipAndCullDistances", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.discreteQueuePriorities, settings, "uint32_t", "discreteQueuePriorities", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.pointSizeRange, 2, settings, "float[2]", "pointSizeRange", "float", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.lineWidthRange, 2, settings, "float[2]", "lineWidthRange", "float", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.pointSizeGranularity, settings, "float", "pointSizeGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.lineWidthGranularity, settings, "float", "lineWidthGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.strictLines, settings, "VkBool32", "strictLines", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.standardSampleLocations, settings, "VkBool32", "standardSampleLocations", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.optimalBufferCopyOffsetAlignment, settings, "VkDeviceSize", "optimalBufferCopyOffsetAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.optimalBufferCopyRowPitchAlignment, settings, "VkDeviceSize", "optimalBufferCopyRowPitchAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.nonCoherentAtomSize, settings, "VkDeviceSize", "nonCoherentAtomSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceMemoryProperties(const VkPhysicalDeviceMemoryProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.memoryTypeCount, settings, "uint32_t", "memoryTypeCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.memoryTypes, std::min(object.memoryTypeCount, VK_MAX_MEMORY_TYPES), settings, "VkMemoryType[VK_MAX_MEMORY_TYPES]", "memoryTypes", "VkMemoryType", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkMemoryType); + dump_separate_members(settings); + dump_type(object.memoryHeapCount, settings, "uint32_t", "memoryHeapCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.memoryHeaps, std::min(object.memoryHeapCount, VK_MAX_MEMORY_HEAPS), settings, "VkMemoryHeap[VK_MAX_MEMORY_HEAPS]", "memoryHeaps", "VkMemoryHeap", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkMemoryHeap); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceSparseProperties(const VkPhysicalDeviceSparseProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.residencyStandard2DBlockShape, settings, "VkBool32", "residencyStandard2DBlockShape", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.residencyStandard2DMultisampleBlockShape, settings, "VkBool32", "residencyStandard2DMultisampleBlockShape", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.residencyStandard3DBlockShape, settings, "VkBool32", "residencyStandard3DBlockShape", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.residencyAlignedMipSize, settings, "VkBool32", "residencyAlignedMipSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.residencyNonResidentStrict, settings, "VkBool32", "residencyNonResidentStrict", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceProperties(const VkPhysicalDeviceProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_api_version(object.apiVersion, settings, "uint32_t", "apiVersion", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.driverVersion, settings, "uint32_t", "driverVersion", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vendorID, settings, "uint32_t", "vendorID", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.deviceID, settings, "uint32_t", "deviceID", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPhysicalDeviceType(object.deviceType, settings, "VkPhysicalDeviceType", "deviceType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_char(object.deviceName, settings, "char[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]", "deviceName", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.pipelineCacheUUID, VK_UUID_SIZE, settings, "uint8_t[VK_UUID_SIZE]", "pipelineCacheUUID", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_VkPhysicalDeviceLimits(object.limits, settings, "VkPhysicalDeviceLimits", "limits", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPhysicalDeviceSparseProperties(object.sparseProperties, settings, "VkPhysicalDeviceSparseProperties", "sparseProperties", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkQueueFamilyProperties(const VkQueueFamilyProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkQueueFlags(object.queueFlags, settings, "VkQueueFlags", "queueFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.queueCount, settings, "uint32_t", "queueCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.timestampValidBits, settings, "uint32_t", "timestampValidBits", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent3D(object.minImageTransferGranularity, settings, "VkExtent3D", "minImageTransferGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDeviceQueueCreateInfo(const VkDeviceQueueCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceQueueCreateFlags(object.flags, settings, "VkDeviceQueueCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.queueCount, settings, "uint32_t", "queueCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pQueuePriorities, object.queueCount, settings, "const float*", "pQueuePriorities", "const float", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDeviceCreateInfo(const VkDeviceCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceCreateFlags(object.flags, settings, "VkDeviceCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.queueCreateInfoCount, settings, "uint32_t", "queueCreateInfoCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pQueueCreateInfos, object.queueCreateInfoCount, settings, "const VkDeviceQueueCreateInfo*", "pQueueCreateInfos", "const VkDeviceQueueCreateInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDeviceQueueCreateInfo); + dump_separate_members(settings); + dump_type(object.enabledLayerCount, settings, "uint32_t", "enabledLayerCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.ppEnabledLayerNames, object.enabledLayerCount, settings, "const char* const*", "ppEnabledLayerNames", "const char*", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_char); + dump_separate_members(settings); + dump_type(object.enabledExtensionCount, settings, "uint32_t", "enabledExtensionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.ppEnabledExtensionNames, object.enabledExtensionCount, settings, "const char* const*", "ppEnabledExtensionNames", "const char*", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_char); + dump_separate_members(settings); + dump_pointer(object.pEnabledFeatures, settings, "const VkPhysicalDeviceFeatures*", "pEnabledFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPhysicalDeviceFeatures); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkExtensionProperties(const VkExtensionProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_char(object.extensionName, settings, "char[VK_MAX_EXTENSION_NAME_SIZE]", "extensionName", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.specVersion, settings, "uint32_t", "specVersion", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkLayerProperties(const VkLayerProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_char(object.layerName, settings, "char[VK_MAX_EXTENSION_NAME_SIZE]", "layerName", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.specVersion, settings, "uint32_t", "specVersion", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.implementationVersion, settings, "uint32_t", "implementationVersion", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_char(object.description, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "description", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSubmitInfo(const VkSubmitInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.waitSemaphoreCount, settings, "uint32_t", "waitSemaphoreCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pWaitSemaphores, object.waitSemaphoreCount, settings, "const VkSemaphore*", "pWaitSemaphores", "const VkSemaphore", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSemaphore); + dump_separate_members(settings); + dump_pointer_array(object.pWaitDstStageMask, object.waitSemaphoreCount, settings, "const VkPipelineStageFlags*", "pWaitDstStageMask", "const VkPipelineStageFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineStageFlags); + dump_separate_members(settings); + dump_type(object.commandBufferCount, settings, "uint32_t", "commandBufferCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pCommandBuffers, object.commandBufferCount, settings, "const VkCommandBuffer*", "pCommandBuffers", "const VkCommandBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkCommandBuffer); + dump_separate_members(settings); + dump_type(object.signalSemaphoreCount, settings, "uint32_t", "signalSemaphoreCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pSignalSemaphores, object.signalSemaphoreCount, settings, "const VkSemaphore*", "pSignalSemaphores", "const VkSemaphore", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSemaphore); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMappedMemoryRange(const VkMappedMemoryRange& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceMemory(object.memory, settings, "VkDeviceMemory", "memory", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.offset, settings, "VkDeviceSize", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMemoryAllocateInfo(const VkMemoryAllocateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.allocationSize, settings, "VkDeviceSize", "allocationSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.memoryTypeIndex, settings, "uint32_t", "memoryTypeIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMemoryRequirements(const VkMemoryRequirements& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.alignment, settings, "VkDeviceSize", "alignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.memoryTypeBits, settings, "uint32_t", "memoryTypeBits", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSparseMemoryBind(const VkSparseMemoryBind& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.resourceOffset, settings, "VkDeviceSize", "resourceOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceMemory(object.memory, settings, "VkDeviceMemory", "memory", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.memoryOffset, settings, "VkDeviceSize", "memoryOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSparseMemoryBindFlags(object.flags, settings, "VkSparseMemoryBindFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSparseBufferMemoryBindInfo(const VkSparseBufferMemoryBindInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkBuffer(object.buffer, settings, "VkBuffer", "buffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bindCount, settings, "uint32_t", "bindCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pBinds, object.bindCount, settings, "const VkSparseMemoryBind*", "pBinds", "const VkSparseMemoryBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSparseMemoryBind); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSparseImageOpaqueMemoryBindInfo(const VkSparseImageOpaqueMemoryBindInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkImage(object.image, settings, "VkImage", "image", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bindCount, settings, "uint32_t", "bindCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pBinds, object.bindCount, settings, "const VkSparseMemoryBind*", "pBinds", "const VkSparseMemoryBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSparseMemoryBind); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImageSubresource(const VkImageSubresource& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkImageAspectFlags(object.aspectMask, settings, "VkImageAspectFlags", "aspectMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.mipLevel, settings, "uint32_t", "mipLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.arrayLayer, settings, "uint32_t", "arrayLayer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSparseImageMemoryBind(const VkSparseImageMemoryBind& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkImageSubresource(object.subresource, settings, "VkImageSubresource", "subresource", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkOffset3D(object.offset, settings, "VkOffset3D", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent3D(object.extent, settings, "VkExtent3D", "extent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceMemory(object.memory, settings, "VkDeviceMemory", "memory", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.memoryOffset, settings, "VkDeviceSize", "memoryOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSparseMemoryBindFlags(object.flags, settings, "VkSparseMemoryBindFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSparseImageMemoryBindInfo(const VkSparseImageMemoryBindInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkImage(object.image, settings, "VkImage", "image", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bindCount, settings, "uint32_t", "bindCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pBinds, object.bindCount, settings, "const VkSparseImageMemoryBind*", "pBinds", "const VkSparseImageMemoryBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSparseImageMemoryBind); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBindSparseInfo(const VkBindSparseInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.waitSemaphoreCount, settings, "uint32_t", "waitSemaphoreCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pWaitSemaphores, object.waitSemaphoreCount, settings, "const VkSemaphore*", "pWaitSemaphores", "const VkSemaphore", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSemaphore); + dump_separate_members(settings); + dump_type(object.bufferBindCount, settings, "uint32_t", "bufferBindCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pBufferBinds, object.bufferBindCount, settings, "const VkSparseBufferMemoryBindInfo*", "pBufferBinds", "const VkSparseBufferMemoryBindInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSparseBufferMemoryBindInfo); + dump_separate_members(settings); + dump_type(object.imageOpaqueBindCount, settings, "uint32_t", "imageOpaqueBindCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pImageOpaqueBinds, object.imageOpaqueBindCount, settings, "const VkSparseImageOpaqueMemoryBindInfo*", "pImageOpaqueBinds", "const VkSparseImageOpaqueMemoryBindInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSparseImageOpaqueMemoryBindInfo); + dump_separate_members(settings); + dump_type(object.imageBindCount, settings, "uint32_t", "imageBindCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pImageBinds, object.imageBindCount, settings, "const VkSparseImageMemoryBindInfo*", "pImageBinds", "const VkSparseImageMemoryBindInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSparseImageMemoryBindInfo); + dump_separate_members(settings); + dump_type(object.signalSemaphoreCount, settings, "uint32_t", "signalSemaphoreCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pSignalSemaphores, object.signalSemaphoreCount, settings, "const VkSemaphore*", "pSignalSemaphores", "const VkSemaphore", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSemaphore); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSparseImageFormatProperties(const VkSparseImageFormatProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkImageAspectFlags(object.aspectMask, settings, "VkImageAspectFlags", "aspectMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent3D(object.imageGranularity, settings, "VkExtent3D", "imageGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSparseImageFormatFlags(object.flags, settings, "VkSparseImageFormatFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSparseImageMemoryRequirements(const VkSparseImageMemoryRequirements& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkSparseImageFormatProperties(object.formatProperties, settings, "VkSparseImageFormatProperties", "formatProperties", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.imageMipTailFirstLod, settings, "uint32_t", "imageMipTailFirstLod", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.imageMipTailSize, settings, "VkDeviceSize", "imageMipTailSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.imageMipTailOffset, settings, "VkDeviceSize", "imageMipTailOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.imageMipTailStride, settings, "VkDeviceSize", "imageMipTailStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkFenceCreateInfo(const VkFenceCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFenceCreateFlags(object.flags, settings, "VkFenceCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSemaphoreCreateInfo(const VkSemaphoreCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSemaphoreCreateFlags(object.flags, settings, "VkSemaphoreCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkQueryPoolCreateInfo(const VkQueryPoolCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkQueryPoolCreateFlags(object.flags, settings, "VkQueryPoolCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkQueryType(object.queryType, settings, "VkQueryType", "queryType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.queryCount, settings, "uint32_t", "queryCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkQueryPipelineStatisticFlags(object.pipelineStatistics, settings, "VkQueryPipelineStatisticFlags", "pipelineStatistics", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBufferCreateInfo(const VkBufferCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBufferCreateFlags(object.flags, settings, "VkBufferCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBufferUsageFlags(object.usage, settings, "VkBufferUsageFlags", "usage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSharingMode(object.sharingMode, settings, "VkSharingMode", "sharingMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.queueFamilyIndexCount, settings, "uint32_t", "queueFamilyIndexCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + if (object.sharingMode == VK_SHARING_MODE_CONCURRENT) { + dump_pointer_array(object.pQueueFamilyIndices, object.queueFamilyIndexCount, settings, "const uint32_t*", "pQueueFamilyIndices", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + } else { + if constexpr (Format == ApiDumpFormat::Text || Format == ApiDumpFormat::Html) { + dump_special("UNUSED", settings, "const uint32_t*", "pQueueFamilyIndices", indents + 1); + } else if constexpr (Format == ApiDumpFormat::Json) { + dump_json_UNUSED(settings, "const uint32_t*", "pQueueFamilyIndices", indents + 2); + } + } + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImageCreateInfo(const VkImageCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageCreateFlags(object.flags, settings, "VkImageCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageType(object.imageType, settings, "VkImageType", "imageType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormat(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent3D(object.extent, settings, "VkExtent3D", "extent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.mipLevels, settings, "uint32_t", "mipLevels", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.arrayLayers, settings, "uint32_t", "arrayLayers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSampleCountFlagBits(object.samples, settings, "VkSampleCountFlagBits", "samples", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageTiling(object.tiling, settings, "VkImageTiling", "tiling", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageUsageFlags(object.usage, settings, "VkImageUsageFlags", "usage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSharingMode(object.sharingMode, settings, "VkSharingMode", "sharingMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.queueFamilyIndexCount, settings, "uint32_t", "queueFamilyIndexCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + if (object.sharingMode == VK_SHARING_MODE_CONCURRENT) { + dump_pointer_array(object.pQueueFamilyIndices, object.queueFamilyIndexCount, settings, "const uint32_t*", "pQueueFamilyIndices", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + } else { + if constexpr (Format == ApiDumpFormat::Text || Format == ApiDumpFormat::Html) { + dump_special("UNUSED", settings, "const uint32_t*", "pQueueFamilyIndices", indents + 1); + } else if constexpr (Format == ApiDumpFormat::Json) { + dump_json_UNUSED(settings, "const uint32_t*", "pQueueFamilyIndices", indents + 2); + } + } + dump_separate_members(settings); + dump_VkImageLayout(object.initialLayout, settings, "VkImageLayout", "initialLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSubresourceLayout(const VkSubresourceLayout& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.offset, settings, "VkDeviceSize", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.rowPitch, settings, "VkDeviceSize", "rowPitch", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.arrayPitch, settings, "VkDeviceSize", "arrayPitch", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.depthPitch, settings, "VkDeviceSize", "depthPitch", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkComponentMapping(const VkComponentMapping& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkComponentSwizzle(object.r, settings, "VkComponentSwizzle", "r", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkComponentSwizzle(object.g, settings, "VkComponentSwizzle", "g", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkComponentSwizzle(object.b, settings, "VkComponentSwizzle", "b", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkComponentSwizzle(object.a, settings, "VkComponentSwizzle", "a", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImageViewCreateInfo(const VkImageViewCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageViewCreateFlags(object.flags, settings, "VkImageViewCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImage(object.image, settings, "VkImage", "image", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageViewType(object.viewType, settings, "VkImageViewType", "viewType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormat(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkComponentMapping(object.components, settings, "VkComponentMapping", "components", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageSubresourceRange(object.subresourceRange, settings, "VkImageSubresourceRange", "subresourceRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCommandPoolCreateInfo(const VkCommandPoolCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkCommandPoolCreateFlags(object.flags, settings, "VkCommandPoolCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCommandBufferAllocateInfo(const VkCommandBufferAllocateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkCommandPool(object.commandPool, settings, "VkCommandPool", "commandPool", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkCommandBufferLevel(object.level, settings, "VkCommandBufferLevel", "level", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.commandBufferCount, settings, "uint32_t", "commandBufferCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCommandBufferInheritanceInfo(const VkCommandBufferInheritanceInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkRenderPass(object.renderPass, settings, "VkRenderPass", "renderPass", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.subpass, settings, "uint32_t", "subpass", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFramebuffer(object.framebuffer, settings, "VkFramebuffer", "framebuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.occlusionQueryEnable, settings, "VkBool32", "occlusionQueryEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkQueryControlFlags(object.queryFlags, settings, "VkQueryControlFlags", "queryFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkQueryPipelineStatisticFlags(object.pipelineStatistics, settings, "VkQueryPipelineStatisticFlags", "pipelineStatistics", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCommandBufferBeginInfo(const VkCommandBufferBeginInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkCommandBufferUsageFlags(object.flags, settings, "VkCommandBufferUsageFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + if (ApiDumpInstance::current().getCmdBufferLevel() == VK_COMMAND_BUFFER_LEVEL_SECONDARY) { + dump_pointer(object.pInheritanceInfo, settings, "const VkCommandBufferInheritanceInfo*", "pInheritanceInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkCommandBufferInheritanceInfo); + } else { + if constexpr (Format == ApiDumpFormat::Text || Format == ApiDumpFormat::Html) { + dump_special("UNUSED", settings, "const VkCommandBufferInheritanceInfo*", "pInheritanceInfo", indents + 1); + } else if constexpr (Format == ApiDumpFormat::Json) { + dump_json_UNUSED(settings, "const VkCommandBufferInheritanceInfo*", "pInheritanceInfo", indents + 2); + } + } + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBufferCopy(const VkBufferCopy& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.srcOffset, settings, "VkDeviceSize", "srcOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dstOffset, settings, "VkDeviceSize", "dstOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImageSubresourceLayers(const VkImageSubresourceLayers& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkImageAspectFlags(object.aspectMask, settings, "VkImageAspectFlags", "aspectMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.mipLevel, settings, "uint32_t", "mipLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.baseArrayLayer, settings, "uint32_t", "baseArrayLayer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.layerCount, settings, "uint32_t", "layerCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBufferImageCopy(const VkBufferImageCopy& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.bufferOffset, settings, "VkDeviceSize", "bufferOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bufferRowLength, settings, "uint32_t", "bufferRowLength", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bufferImageHeight, settings, "uint32_t", "bufferImageHeight", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageSubresourceLayers(object.imageSubresource, settings, "VkImageSubresourceLayers", "imageSubresource", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkOffset3D(object.imageOffset, settings, "VkOffset3D", "imageOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent3D(object.imageExtent, settings, "VkExtent3D", "imageExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImageCopy(const VkImageCopy& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkImageSubresourceLayers(object.srcSubresource, settings, "VkImageSubresourceLayers", "srcSubresource", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkOffset3D(object.srcOffset, settings, "VkOffset3D", "srcOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageSubresourceLayers(object.dstSubresource, settings, "VkImageSubresourceLayers", "dstSubresource", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkOffset3D(object.dstOffset, settings, "VkOffset3D", "dstOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent3D(object.extent, settings, "VkExtent3D", "extent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDispatchIndirectCommand(const VkDispatchIndirectCommand& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.x, settings, "uint32_t", "x", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.y, settings, "uint32_t", "y", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.z, settings, "uint32_t", "z", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineCacheHeaderVersionOne(const VkPipelineCacheHeaderVersionOne& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.headerSize, settings, "uint32_t", "headerSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineCacheHeaderVersion(object.headerVersion, settings, "VkPipelineCacheHeaderVersion", "headerVersion", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vendorID, settings, "uint32_t", "vendorID", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.deviceID, settings, "uint32_t", "deviceID", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.pipelineCacheUUID, VK_UUID_SIZE, settings, "uint8_t[VK_UUID_SIZE]", "pipelineCacheUUID", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkEventCreateInfo(const VkEventCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkEventCreateFlags(object.flags, settings, "VkEventCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBufferViewCreateInfo(const VkBufferViewCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBufferViewCreateFlags(object.flags, settings, "VkBufferViewCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBuffer(object.buffer, settings, "VkBuffer", "buffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormat(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.offset, settings, "VkDeviceSize", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.range, settings, "VkDeviceSize", "range", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkShaderModuleCreateInfo(const VkShaderModuleCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkShaderModuleCreateFlags(object.flags, settings, "VkShaderModuleCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.codeSize, settings, "size_t", "codeSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + + if (settings.showShader()) { + dump_spirv(object.pCode, object.codeSize / 4, settings, "const uint32_t*", "pCode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + } else { + dump_special("SHADER DATA", settings, "const uint32_t*", "pCode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + } + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineCacheCreateInfo(const VkPipelineCacheCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineCacheCreateFlags(object.flags, settings, "VkPipelineCacheCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.initialDataSize, settings, "size_t", "initialDataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pInitialData, settings, "const void*", "pInitialData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSpecializationMapEntry(const VkSpecializationMapEntry& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.constantID, settings, "uint32_t", "constantID", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.offset, settings, "uint32_t", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.size, settings, "size_t", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSpecializationInfo(const VkSpecializationInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.mapEntryCount, settings, "uint32_t", "mapEntryCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pMapEntries, object.mapEntryCount, settings, "const VkSpecializationMapEntry*", "pMapEntries", "const VkSpecializationMapEntry", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSpecializationMapEntry); + dump_separate_members(settings); + dump_type(object.dataSize, settings, "size_t", "dataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pData, settings, "const void*", "pData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineShaderStageCreateInfo(const VkPipelineShaderStageCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineShaderStageCreateFlags(object.flags, settings, "VkPipelineShaderStageCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkShaderStageFlagBits(object.stage, settings, "VkShaderStageFlagBits", "stage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkShaderModule(object.module, settings, "VkShaderModule", "module", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_char(object.pName, settings, "const char*", "pName", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pSpecializationInfo, settings, "const VkSpecializationInfo*", "pSpecializationInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSpecializationInfo); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkComputePipelineCreateInfo(const VkComputePipelineCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineCreateFlags(object.flags, settings, "VkPipelineCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineShaderStageCreateInfo(object.stage, settings, "VkPipelineShaderStageCreateInfo", "stage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineLayout(object.layout, settings, "VkPipelineLayout", "layout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipeline(object.basePipelineHandle, settings, "VkPipeline", "basePipelineHandle", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.basePipelineIndex, settings, "int32_t", "basePipelineIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPushConstantRange(const VkPushConstantRange& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkShaderStageFlags(object.stageFlags, settings, "VkShaderStageFlags", "stageFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.offset, settings, "uint32_t", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.size, settings, "uint32_t", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineLayoutCreateInfo(const VkPipelineLayoutCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineLayoutCreateFlags(object.flags, settings, "VkPipelineLayoutCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.setLayoutCount, settings, "uint32_t", "setLayoutCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pSetLayouts, object.setLayoutCount, settings, "const VkDescriptorSetLayout*", "pSetLayouts", "const VkDescriptorSetLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorSetLayout); + dump_separate_members(settings); + dump_type(object.pushConstantRangeCount, settings, "uint32_t", "pushConstantRangeCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pPushConstantRanges, object.pushConstantRangeCount, settings, "const VkPushConstantRange*", "pPushConstantRanges", "const VkPushConstantRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPushConstantRange); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSamplerCreateInfo(const VkSamplerCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSamplerCreateFlags(object.flags, settings, "VkSamplerCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFilter(object.magFilter, settings, "VkFilter", "magFilter", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFilter(object.minFilter, settings, "VkFilter", "minFilter", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSamplerMipmapMode(object.mipmapMode, settings, "VkSamplerMipmapMode", "mipmapMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSamplerAddressMode(object.addressModeU, settings, "VkSamplerAddressMode", "addressModeU", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSamplerAddressMode(object.addressModeV, settings, "VkSamplerAddressMode", "addressModeV", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSamplerAddressMode(object.addressModeW, settings, "VkSamplerAddressMode", "addressModeW", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.mipLodBias, settings, "float", "mipLodBias", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.anisotropyEnable, settings, "VkBool32", "anisotropyEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxAnisotropy, settings, "float", "maxAnisotropy", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.compareEnable, settings, "VkBool32", "compareEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkCompareOp(object.compareOp, settings, "VkCompareOp", "compareOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minLod, settings, "float", "minLod", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxLod, settings, "float", "maxLod", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBorderColor(object.borderColor, settings, "VkBorderColor", "borderColor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.unnormalizedCoordinates, settings, "VkBool32", "unnormalizedCoordinates", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCopyDescriptorSet(const VkCopyDescriptorSet& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDescriptorSet(object.srcSet, settings, "VkDescriptorSet", "srcSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.srcBinding, settings, "uint32_t", "srcBinding", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.srcArrayElement, settings, "uint32_t", "srcArrayElement", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDescriptorSet(object.dstSet, settings, "VkDescriptorSet", "dstSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dstBinding, settings, "uint32_t", "dstBinding", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dstArrayElement, settings, "uint32_t", "dstArrayElement", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorCount, settings, "uint32_t", "descriptorCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDescriptorBufferInfo(const VkDescriptorBufferInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkBuffer(object.buffer, settings, "VkBuffer", "buffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.offset, settings, "VkDeviceSize", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.range, settings, "VkDeviceSize", "range", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDescriptorImageInfo(const VkDescriptorImageInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkSampler(object.sampler, settings, "VkSampler", "sampler", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageView(object.imageView, settings, "VkImageView", "imageView", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(object.imageLayout, settings, "VkImageLayout", "imageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDescriptorPoolSize(const VkDescriptorPoolSize& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkDescriptorType(object.type, settings, "VkDescriptorType", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorCount, settings, "uint32_t", "descriptorCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDescriptorPoolCreateInfo(const VkDescriptorPoolCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDescriptorPoolCreateFlags(object.flags, settings, "VkDescriptorPoolCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxSets, settings, "uint32_t", "maxSets", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.poolSizeCount, settings, "uint32_t", "poolSizeCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pPoolSizes, object.poolSizeCount, settings, "const VkDescriptorPoolSize*", "pPoolSizes", "const VkDescriptorPoolSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorPoolSize); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDescriptorSetAllocateInfo(const VkDescriptorSetAllocateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDescriptorPool(object.descriptorPool, settings, "VkDescriptorPool", "descriptorPool", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorSetCount, settings, "uint32_t", "descriptorSetCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pSetLayouts, object.descriptorSetCount, settings, "const VkDescriptorSetLayout*", "pSetLayouts", "const VkDescriptorSetLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorSetLayout); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDescriptorSetLayoutBinding(const VkDescriptorSetLayoutBinding& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.binding, settings, "uint32_t", "binding", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDescriptorType(object.descriptorType, settings, "VkDescriptorType", "descriptorType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorCount, settings, "uint32_t", "descriptorCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkShaderStageFlags(object.stageFlags, settings, "VkShaderStageFlags", "stageFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + if ((object.descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER) || (object.descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)) { + dump_pointer_array(object.pImmutableSamplers, object.descriptorCount, settings, "const VkSampler*", "pImmutableSamplers", "const VkSampler", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSampler); + } else { + if constexpr (Format == ApiDumpFormat::Text || Format == ApiDumpFormat::Html) { + dump_special("UNUSED", settings, "const VkSampler*", "pImmutableSamplers", indents + 1); + } else if constexpr (Format == ApiDumpFormat::Json) { + dump_json_UNUSED(settings, "const VkSampler*", "pImmutableSamplers", indents + 2); + } + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDescriptorSetLayoutCreateInfo(const VkDescriptorSetLayoutCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDescriptorSetLayoutCreateFlags(object.flags, settings, "VkDescriptorSetLayoutCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bindingCount, settings, "uint32_t", "bindingCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pBindings, object.bindingCount, settings, "const VkDescriptorSetLayoutBinding*", "pBindings", "const VkDescriptorSetLayoutBinding", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorSetLayoutBinding); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkWriteDescriptorSet(const VkWriteDescriptorSet& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDescriptorSet(object.dstSet, settings, "VkDescriptorSet", "dstSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dstBinding, settings, "uint32_t", "dstBinding", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dstArrayElement, settings, "uint32_t", "dstArrayElement", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorCount, settings, "uint32_t", "descriptorCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDescriptorType(object.descriptorType, settings, "VkDescriptorType", "descriptorType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + if ((object.descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER) || (object.descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER) || (object.descriptorType == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE) || (object.descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE) || (object.descriptorType == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT)) { + dump_pointer_array(object.pImageInfo, object.descriptorCount, settings, "const VkDescriptorImageInfo*", "pImageInfo", "const VkDescriptorImageInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorImageInfo); + } else { + if constexpr (Format == ApiDumpFormat::Text || Format == ApiDumpFormat::Html) { + dump_special("UNUSED", settings, "const VkDescriptorImageInfo*", "pImageInfo", indents + 1); + } else if constexpr (Format == ApiDumpFormat::Json) { + dump_json_UNUSED(settings, "const VkDescriptorImageInfo*", "pImageInfo", indents + 2); + } + } + dump_separate_members(settings); + if ((object.descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER) || (object.descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER) || (object.descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC) || (object.descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC)) { + dump_pointer_array(object.pBufferInfo, object.descriptorCount, settings, "const VkDescriptorBufferInfo*", "pBufferInfo", "const VkDescriptorBufferInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorBufferInfo); + } else { + if constexpr (Format == ApiDumpFormat::Text || Format == ApiDumpFormat::Html) { + dump_special("UNUSED", settings, "const VkDescriptorBufferInfo*", "pBufferInfo", indents + 1); + } else if constexpr (Format == ApiDumpFormat::Json) { + dump_json_UNUSED(settings, "const VkDescriptorBufferInfo*", "pBufferInfo", indents + 2); + } + } + dump_separate_members(settings); + if ((object.descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER) || (object.descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER)) { + dump_pointer_array(object.pTexelBufferView, object.descriptorCount, settings, "const VkBufferView*", "pTexelBufferView", "const VkBufferView", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkBufferView); + } else { + if constexpr (Format == ApiDumpFormat::Text || Format == ApiDumpFormat::Html) { + dump_special("UNUSED", settings, "const VkBufferView*", "pTexelBufferView", indents + 1); + } else if constexpr (Format == ApiDumpFormat::Json) { + dump_json_UNUSED(settings, "const VkBufferView*", "pTexelBufferView", indents + 2); + } + } + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkClearColorValue(const VkClearColorValue& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_union, type_name, var_name, indents, address); + dump_single_array(object.float32, 4, settings, "float[4]", "float32", "float", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.int32, 4, settings, "int32_t[4]", "int32", "int32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.uint32, 4, settings, "uint32_t[4]", "uint32", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDrawIndexedIndirectCommand(const VkDrawIndexedIndirectCommand& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.indexCount, settings, "uint32_t", "indexCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.instanceCount, settings, "uint32_t", "instanceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.firstIndex, settings, "uint32_t", "firstIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vertexOffset, settings, "int32_t", "vertexOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.firstInstance, settings, "uint32_t", "firstInstance", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDrawIndirectCommand(const VkDrawIndirectCommand& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.vertexCount, settings, "uint32_t", "vertexCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.instanceCount, settings, "uint32_t", "instanceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.firstVertex, settings, "uint32_t", "firstVertex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.firstInstance, settings, "uint32_t", "firstInstance", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVertexInputBindingDescription(const VkVertexInputBindingDescription& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.binding, settings, "uint32_t", "binding", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.stride, settings, "uint32_t", "stride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVertexInputRate(object.inputRate, settings, "VkVertexInputRate", "inputRate", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVertexInputAttributeDescription(const VkVertexInputAttributeDescription& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.location, settings, "uint32_t", "location", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.binding, settings, "uint32_t", "binding", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormat(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.offset, settings, "uint32_t", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineVertexInputStateCreateInfo(const VkPipelineVertexInputStateCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineVertexInputStateCreateFlags(object.flags, settings, "VkPipelineVertexInputStateCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vertexBindingDescriptionCount, settings, "uint32_t", "vertexBindingDescriptionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pVertexBindingDescriptions, object.vertexBindingDescriptionCount, settings, "const VkVertexInputBindingDescription*", "pVertexBindingDescriptions", "const VkVertexInputBindingDescription", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkVertexInputBindingDescription); + dump_separate_members(settings); + dump_type(object.vertexAttributeDescriptionCount, settings, "uint32_t", "vertexAttributeDescriptionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pVertexAttributeDescriptions, object.vertexAttributeDescriptionCount, settings, "const VkVertexInputAttributeDescription*", "pVertexAttributeDescriptions", "const VkVertexInputAttributeDescription", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkVertexInputAttributeDescription); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineInputAssemblyStateCreateInfo(const VkPipelineInputAssemblyStateCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineInputAssemblyStateCreateFlags(object.flags, settings, "VkPipelineInputAssemblyStateCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPrimitiveTopology(object.topology, settings, "VkPrimitiveTopology", "topology", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.primitiveRestartEnable, settings, "VkBool32", "primitiveRestartEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineTessellationStateCreateInfo(const VkPipelineTessellationStateCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineTessellationStateCreateFlags(object.flags, settings, "VkPipelineTessellationStateCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.patchControlPoints, settings, "uint32_t", "patchControlPoints", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkViewport(const VkViewport& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.x, settings, "float", "x", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.y, settings, "float", "y", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.width, settings, "float", "width", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.height, settings, "float", "height", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minDepth, settings, "float", "minDepth", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDepth, settings, "float", "maxDepth", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineViewportStateCreateInfo(const VkPipelineViewportStateCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineViewportStateCreateFlags(object.flags, settings, "VkPipelineViewportStateCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.viewportCount, settings, "uint32_t", "viewportCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + if (!ApiDumpInstance::current().getIsDynamicViewport()) { + dump_pointer_array(object.pViewports, object.viewportCount, settings, "const VkViewport*", "pViewports", "const VkViewport", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkViewport); + } else { + if constexpr (Format == ApiDumpFormat::Text || Format == ApiDumpFormat::Html) { + dump_special("UNUSED", settings, "const VkViewport*", "pViewports", indents + 1); + } else if constexpr (Format == ApiDumpFormat::Json) { + dump_json_UNUSED(settings, "const VkViewport*", "pViewports", indents + 2); + } + } + dump_separate_members(settings); + dump_type(object.scissorCount, settings, "uint32_t", "scissorCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + if (!ApiDumpInstance::current().getIsDynamicScissor()) { + dump_pointer_array(object.pScissors, object.scissorCount, settings, "const VkRect2D*", "pScissors", "const VkRect2D", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkRect2D); + } else { + if constexpr (Format == ApiDumpFormat::Text || Format == ApiDumpFormat::Html) { + dump_special("UNUSED", settings, "const VkRect2D*", "pScissors", indents + 1); + } else if constexpr (Format == ApiDumpFormat::Json) { + dump_json_UNUSED(settings, "const VkRect2D*", "pScissors", indents + 2); + } + } + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineRasterizationStateCreateInfo(const VkPipelineRasterizationStateCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineRasterizationStateCreateFlags(object.flags, settings, "VkPipelineRasterizationStateCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.depthClampEnable, settings, "VkBool32", "depthClampEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.rasterizerDiscardEnable, settings, "VkBool32", "rasterizerDiscardEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPolygonMode(object.polygonMode, settings, "VkPolygonMode", "polygonMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkCullModeFlags(object.cullMode, settings, "VkCullModeFlags", "cullMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFrontFace(object.frontFace, settings, "VkFrontFace", "frontFace", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.depthBiasEnable, settings, "VkBool32", "depthBiasEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.depthBiasConstantFactor, settings, "float", "depthBiasConstantFactor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.depthBiasClamp, settings, "float", "depthBiasClamp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.depthBiasSlopeFactor, settings, "float", "depthBiasSlopeFactor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.lineWidth, settings, "float", "lineWidth", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineMultisampleStateCreateInfo(const VkPipelineMultisampleStateCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineMultisampleStateCreateFlags(object.flags, settings, "VkPipelineMultisampleStateCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSampleCountFlagBits(object.rasterizationSamples, settings, "VkSampleCountFlagBits", "rasterizationSamples", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sampleShadingEnable, settings, "VkBool32", "sampleShadingEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minSampleShading, settings, "float", "minSampleShading", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pSampleMask, (object.rasterizationSamples + 31) / 32, settings, "const VkSampleMask*", "pSampleMask", "const VkSampleMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.alphaToCoverageEnable, settings, "VkBool32", "alphaToCoverageEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.alphaToOneEnable, settings, "VkBool32", "alphaToOneEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkStencilOpState(const VkStencilOpState& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStencilOp(object.failOp, settings, "VkStencilOp", "failOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkStencilOp(object.passOp, settings, "VkStencilOp", "passOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkStencilOp(object.depthFailOp, settings, "VkStencilOp", "depthFailOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkCompareOp(object.compareOp, settings, "VkCompareOp", "compareOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.compareMask, settings, "uint32_t", "compareMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.writeMask, settings, "uint32_t", "writeMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reference, settings, "uint32_t", "reference", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineDepthStencilStateCreateInfo(const VkPipelineDepthStencilStateCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineDepthStencilStateCreateFlags(object.flags, settings, "VkPipelineDepthStencilStateCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.depthTestEnable, settings, "VkBool32", "depthTestEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.depthWriteEnable, settings, "VkBool32", "depthWriteEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkCompareOp(object.depthCompareOp, settings, "VkCompareOp", "depthCompareOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.depthBoundsTestEnable, settings, "VkBool32", "depthBoundsTestEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.stencilTestEnable, settings, "VkBool32", "stencilTestEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkStencilOpState(object.front, settings, "VkStencilOpState", "front", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkStencilOpState(object.back, settings, "VkStencilOpState", "back", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minDepthBounds, settings, "float", "minDepthBounds", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDepthBounds, settings, "float", "maxDepthBounds", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineColorBlendAttachmentState(const VkPipelineColorBlendAttachmentState& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.blendEnable, settings, "VkBool32", "blendEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBlendFactor(object.srcColorBlendFactor, settings, "VkBlendFactor", "srcColorBlendFactor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBlendFactor(object.dstColorBlendFactor, settings, "VkBlendFactor", "dstColorBlendFactor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBlendOp(object.colorBlendOp, settings, "VkBlendOp", "colorBlendOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBlendFactor(object.srcAlphaBlendFactor, settings, "VkBlendFactor", "srcAlphaBlendFactor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBlendFactor(object.dstAlphaBlendFactor, settings, "VkBlendFactor", "dstAlphaBlendFactor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBlendOp(object.alphaBlendOp, settings, "VkBlendOp", "alphaBlendOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkColorComponentFlags(object.colorWriteMask, settings, "VkColorComponentFlags", "colorWriteMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineColorBlendStateCreateInfo(const VkPipelineColorBlendStateCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineColorBlendStateCreateFlags(object.flags, settings, "VkPipelineColorBlendStateCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.logicOpEnable, settings, "VkBool32", "logicOpEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkLogicOp(object.logicOp, settings, "VkLogicOp", "logicOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.attachmentCount, settings, "uint32_t", "attachmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pAttachments, object.attachmentCount, settings, "const VkPipelineColorBlendAttachmentState*", "pAttachments", "const VkPipelineColorBlendAttachmentState", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineColorBlendAttachmentState); + dump_separate_members(settings); + dump_single_array(object.blendConstants, 4, settings, "float[4]", "blendConstants", "float", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineDynamicStateCreateInfo(const VkPipelineDynamicStateCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineDynamicStateCreateFlags(object.flags, settings, "VkPipelineDynamicStateCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dynamicStateCount, settings, "uint32_t", "dynamicStateCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pDynamicStates, object.dynamicStateCount, settings, "const VkDynamicState*", "pDynamicStates", "const VkDynamicState", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDynamicState); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkGraphicsPipelineCreateInfo(const VkGraphicsPipelineCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + ApiDumpInstance::current().setIsDynamicViewport(object.pDynamicState && std::count(object.pDynamicState->pDynamicStates, object.pDynamicState->pDynamicStates + object.pDynamicState->dynamicStateCount, VK_DYNAMIC_STATE_VIEWPORT) > 0); + ApiDumpInstance::current().setIsDynamicScissor(object.pDynamicState && std::count(object.pDynamicState->pDynamicStates, object.pDynamicState->pDynamicStates + object.pDynamicState->dynamicStateCount, VK_DYNAMIC_STATE_SCISSOR)); + ApiDumpInstance::current().setIsGPLPreRasterOrFragmentShader(checkForGPLPreRasterOrFragmentShader(object)); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineCreateFlags(object.flags, settings, "VkPipelineCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.stageCount, settings, "uint32_t", "stageCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pStages, object.stageCount, settings, "const VkPipelineShaderStageCreateInfo*", "pStages", "const VkPipelineShaderStageCreateInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineShaderStageCreateInfo); + dump_separate_members(settings); + dump_pointer(object.pVertexInputState, settings, "const VkPipelineVertexInputStateCreateInfo*", "pVertexInputState", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineVertexInputStateCreateInfo); + dump_separate_members(settings); + dump_pointer(object.pInputAssemblyState, settings, "const VkPipelineInputAssemblyStateCreateInfo*", "pInputAssemblyState", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineInputAssemblyStateCreateInfo); + dump_separate_members(settings); + dump_pointer(object.pTessellationState, settings, "const VkPipelineTessellationStateCreateInfo*", "pTessellationState", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineTessellationStateCreateInfo); + dump_separate_members(settings); + dump_pointer(object.pViewportState, settings, "const VkPipelineViewportStateCreateInfo*", "pViewportState", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineViewportStateCreateInfo); + dump_separate_members(settings); + dump_pointer(object.pRasterizationState, settings, "const VkPipelineRasterizationStateCreateInfo*", "pRasterizationState", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineRasterizationStateCreateInfo); + dump_separate_members(settings); + dump_pointer(object.pMultisampleState, settings, "const VkPipelineMultisampleStateCreateInfo*", "pMultisampleState", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineMultisampleStateCreateInfo); + dump_separate_members(settings); + dump_pointer(object.pDepthStencilState, settings, "const VkPipelineDepthStencilStateCreateInfo*", "pDepthStencilState", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineDepthStencilStateCreateInfo); + dump_separate_members(settings); + dump_pointer(object.pColorBlendState, settings, "const VkPipelineColorBlendStateCreateInfo*", "pColorBlendState", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineColorBlendStateCreateInfo); + dump_separate_members(settings); + dump_pointer(object.pDynamicState, settings, "const VkPipelineDynamicStateCreateInfo*", "pDynamicState", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineDynamicStateCreateInfo); + dump_separate_members(settings); + dump_VkPipelineLayout(object.layout, settings, "VkPipelineLayout", "layout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkRenderPass(object.renderPass, settings, "VkRenderPass", "renderPass", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.subpass, settings, "uint32_t", "subpass", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipeline(object.basePipelineHandle, settings, "VkPipeline", "basePipelineHandle", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.basePipelineIndex, settings, "int32_t", "basePipelineIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAttachmentDescription(const VkAttachmentDescription& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkAttachmentDescriptionFlags(object.flags, settings, "VkAttachmentDescriptionFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormat(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSampleCountFlagBits(object.samples, settings, "VkSampleCountFlagBits", "samples", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAttachmentLoadOp(object.loadOp, settings, "VkAttachmentLoadOp", "loadOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAttachmentStoreOp(object.storeOp, settings, "VkAttachmentStoreOp", "storeOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAttachmentLoadOp(object.stencilLoadOp, settings, "VkAttachmentLoadOp", "stencilLoadOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAttachmentStoreOp(object.stencilStoreOp, settings, "VkAttachmentStoreOp", "stencilStoreOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(object.initialLayout, settings, "VkImageLayout", "initialLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(object.finalLayout, settings, "VkImageLayout", "finalLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAttachmentReference(const VkAttachmentReference& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.attachment, settings, "uint32_t", "attachment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(object.layout, settings, "VkImageLayout", "layout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkFramebufferCreateInfo(const VkFramebufferCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFramebufferCreateFlags(object.flags, settings, "VkFramebufferCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkRenderPass(object.renderPass, settings, "VkRenderPass", "renderPass", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.attachmentCount, settings, "uint32_t", "attachmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pAttachments, object.attachmentCount, settings, "const VkImageView*", "pAttachments", "const VkImageView", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkImageView); + dump_separate_members(settings); + dump_type(object.width, settings, "uint32_t", "width", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.height, settings, "uint32_t", "height", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.layers, settings, "uint32_t", "layers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSubpassDescription(const VkSubpassDescription& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkSubpassDescriptionFlags(object.flags, settings, "VkSubpassDescriptionFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineBindPoint(object.pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.inputAttachmentCount, settings, "uint32_t", "inputAttachmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pInputAttachments, object.inputAttachmentCount, settings, "const VkAttachmentReference*", "pInputAttachments", "const VkAttachmentReference", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkAttachmentReference); + dump_separate_members(settings); + dump_type(object.colorAttachmentCount, settings, "uint32_t", "colorAttachmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pColorAttachments, object.colorAttachmentCount, settings, "const VkAttachmentReference*", "pColorAttachments", "const VkAttachmentReference", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkAttachmentReference); + dump_separate_members(settings); + dump_pointer_array(object.pResolveAttachments, object.colorAttachmentCount, settings, "const VkAttachmentReference*", "pResolveAttachments", "const VkAttachmentReference", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkAttachmentReference); + dump_separate_members(settings); + dump_pointer(object.pDepthStencilAttachment, settings, "const VkAttachmentReference*", "pDepthStencilAttachment", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkAttachmentReference); + dump_separate_members(settings); + dump_type(object.preserveAttachmentCount, settings, "uint32_t", "preserveAttachmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pPreserveAttachments, object.preserveAttachmentCount, settings, "const uint32_t*", "pPreserveAttachments", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSubpassDependency(const VkSubpassDependency& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.srcSubpass, settings, "uint32_t", "srcSubpass", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dstSubpass, settings, "uint32_t", "dstSubpass", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineStageFlags(object.srcStageMask, settings, "VkPipelineStageFlags", "srcStageMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineStageFlags(object.dstStageMask, settings, "VkPipelineStageFlags", "dstStageMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccessFlags(object.srcAccessMask, settings, "VkAccessFlags", "srcAccessMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccessFlags(object.dstAccessMask, settings, "VkAccessFlags", "dstAccessMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDependencyFlags(object.dependencyFlags, settings, "VkDependencyFlags", "dependencyFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkRenderPassCreateInfo(const VkRenderPassCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkRenderPassCreateFlags(object.flags, settings, "VkRenderPassCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.attachmentCount, settings, "uint32_t", "attachmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pAttachments, object.attachmentCount, settings, "const VkAttachmentDescription*", "pAttachments", "const VkAttachmentDescription", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkAttachmentDescription); + dump_separate_members(settings); + dump_type(object.subpassCount, settings, "uint32_t", "subpassCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pSubpasses, object.subpassCount, settings, "const VkSubpassDescription*", "pSubpasses", "const VkSubpassDescription", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSubpassDescription); + dump_separate_members(settings); + dump_type(object.dependencyCount, settings, "uint32_t", "dependencyCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pDependencies, object.dependencyCount, settings, "const VkSubpassDependency*", "pDependencies", "const VkSubpassDependency", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSubpassDependency); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkClearDepthStencilValue(const VkClearDepthStencilValue& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.depth, settings, "float", "depth", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.stencil, settings, "uint32_t", "stencil", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkClearValue(const VkClearValue& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_union, type_name, var_name, indents, address); + dump_VkClearColorValue(object.color, settings, "VkClearColorValue", "color", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkClearDepthStencilValue(object.depthStencil, settings, "VkClearDepthStencilValue", "depthStencil", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkClearAttachment(const VkClearAttachment& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkImageAspectFlags(object.aspectMask, settings, "VkImageAspectFlags", "aspectMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.colorAttachment, settings, "uint32_t", "colorAttachment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkClearValue(object.clearValue, settings, "VkClearValue", "clearValue", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkClearRect(const VkClearRect& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkRect2D(object.rect, settings, "VkRect2D", "rect", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.baseArrayLayer, settings, "uint32_t", "baseArrayLayer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.layerCount, settings, "uint32_t", "layerCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImageBlit(const VkImageBlit& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkImageSubresourceLayers(object.srcSubresource, settings, "VkImageSubresourceLayers", "srcSubresource", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.srcOffsets, 2, settings, "VkOffset3D[2]", "srcOffsets", "VkOffset3D", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkOffset3D); + dump_separate_members(settings); + dump_VkImageSubresourceLayers(object.dstSubresource, settings, "VkImageSubresourceLayers", "dstSubresource", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.dstOffsets, 2, settings, "VkOffset3D[2]", "dstOffsets", "VkOffset3D", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkOffset3D); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImageResolve(const VkImageResolve& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkImageSubresourceLayers(object.srcSubresource, settings, "VkImageSubresourceLayers", "srcSubresource", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkOffset3D(object.srcOffset, settings, "VkOffset3D", "srcOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageSubresourceLayers(object.dstSubresource, settings, "VkImageSubresourceLayers", "dstSubresource", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkOffset3D(object.dstOffset, settings, "VkOffset3D", "dstOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent3D(object.extent, settings, "VkExtent3D", "extent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkRenderPassBeginInfo(const VkRenderPassBeginInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkRenderPass(object.renderPass, settings, "VkRenderPass", "renderPass", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFramebuffer(object.framebuffer, settings, "VkFramebuffer", "framebuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkRect2D(object.renderArea, settings, "VkRect2D", "renderArea", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.clearValueCount, settings, "uint32_t", "clearValueCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pClearValues, object.clearValueCount, settings, "const VkClearValue*", "pClearValues", "const VkClearValue", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkClearValue); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBindBufferMemoryInfo(const VkBindBufferMemoryInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBuffer(object.buffer, settings, "VkBuffer", "buffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceMemory(object.memory, settings, "VkDeviceMemory", "memory", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.memoryOffset, settings, "VkDeviceSize", "memoryOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBindImageMemoryInfo(const VkBindImageMemoryInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImage(object.image, settings, "VkImage", "image", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceMemory(object.memory, settings, "VkDeviceMemory", "memory", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.memoryOffset, settings, "VkDeviceSize", "memoryOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMemoryDedicatedRequirements(const VkMemoryDedicatedRequirements& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.prefersDedicatedAllocation, settings, "VkBool32", "prefersDedicatedAllocation", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.requiresDedicatedAllocation, settings, "VkBool32", "requiresDedicatedAllocation", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMemoryDedicatedAllocateInfo(const VkMemoryDedicatedAllocateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImage(object.image, settings, "VkImage", "image", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBuffer(object.buffer, settings, "VkBuffer", "buffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMemoryAllocateFlagsInfo(const VkMemoryAllocateFlagsInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkMemoryAllocateFlags(object.flags, settings, "VkMemoryAllocateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.deviceMask, settings, "uint32_t", "deviceMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDeviceGroupCommandBufferBeginInfo(const VkDeviceGroupCommandBufferBeginInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.deviceMask, settings, "uint32_t", "deviceMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDeviceGroupSubmitInfo(const VkDeviceGroupSubmitInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.waitSemaphoreCount, settings, "uint32_t", "waitSemaphoreCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pWaitSemaphoreDeviceIndices, object.waitSemaphoreCount, settings, "const uint32_t*", "pWaitSemaphoreDeviceIndices", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.commandBufferCount, settings, "uint32_t", "commandBufferCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pCommandBufferDeviceMasks, object.commandBufferCount, settings, "const uint32_t*", "pCommandBufferDeviceMasks", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.signalSemaphoreCount, settings, "uint32_t", "signalSemaphoreCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pSignalSemaphoreDeviceIndices, object.signalSemaphoreCount, settings, "const uint32_t*", "pSignalSemaphoreDeviceIndices", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDeviceGroupBindSparseInfo(const VkDeviceGroupBindSparseInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.resourceDeviceIndex, settings, "uint32_t", "resourceDeviceIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.memoryDeviceIndex, settings, "uint32_t", "memoryDeviceIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBindBufferMemoryDeviceGroupInfo(const VkBindBufferMemoryDeviceGroupInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.deviceIndexCount, settings, "uint32_t", "deviceIndexCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pDeviceIndices, object.deviceIndexCount, settings, "const uint32_t*", "pDeviceIndices", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBindImageMemoryDeviceGroupInfo(const VkBindImageMemoryDeviceGroupInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.deviceIndexCount, settings, "uint32_t", "deviceIndexCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pDeviceIndices, object.deviceIndexCount, settings, "const uint32_t*", "pDeviceIndices", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.splitInstanceBindRegionCount, settings, "uint32_t", "splitInstanceBindRegionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pSplitInstanceBindRegions, object.splitInstanceBindRegionCount, settings, "const VkRect2D*", "pSplitInstanceBindRegions", "const VkRect2D", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkRect2D); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceGroupProperties(const VkPhysicalDeviceGroupProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.physicalDeviceCount, settings, "uint32_t", "physicalDeviceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.physicalDevices, std::min(object.physicalDeviceCount, VK_MAX_DEVICE_GROUP_SIZE), settings, "VkPhysicalDevice[VK_MAX_DEVICE_GROUP_SIZE]", "physicalDevices", "VkPhysicalDevice", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPhysicalDevice); + dump_separate_members(settings); + dump_type(object.subsetAllocation, settings, "VkBool32", "subsetAllocation", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDeviceGroupDeviceCreateInfo(const VkDeviceGroupDeviceCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.physicalDeviceCount, settings, "uint32_t", "physicalDeviceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pPhysicalDevices, object.physicalDeviceCount, settings, "const VkPhysicalDevice*", "pPhysicalDevices", "const VkPhysicalDevice", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPhysicalDevice); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBufferMemoryRequirementsInfo2(const VkBufferMemoryRequirementsInfo2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBuffer(object.buffer, settings, "VkBuffer", "buffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImageMemoryRequirementsInfo2(const VkImageMemoryRequirementsInfo2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImage(object.image, settings, "VkImage", "image", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImageSparseMemoryRequirementsInfo2(const VkImageSparseMemoryRequirementsInfo2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImage(object.image, settings, "VkImage", "image", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMemoryRequirements2(const VkMemoryRequirements2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkMemoryRequirements(object.memoryRequirements, settings, "VkMemoryRequirements", "memoryRequirements", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSparseImageMemoryRequirements2(const VkSparseImageMemoryRequirements2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSparseImageMemoryRequirements(object.memoryRequirements, settings, "VkSparseImageMemoryRequirements", "memoryRequirements", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceFeatures2(const VkPhysicalDeviceFeatures2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPhysicalDeviceFeatures(object.features, settings, "VkPhysicalDeviceFeatures", "features", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceProperties2(const VkPhysicalDeviceProperties2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPhysicalDeviceProperties(object.properties, settings, "VkPhysicalDeviceProperties", "properties", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkFormatProperties2(const VkFormatProperties2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormatProperties(object.formatProperties, settings, "VkFormatProperties", "formatProperties", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImageFormatProperties2(const VkImageFormatProperties2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageFormatProperties(object.imageFormatProperties, settings, "VkImageFormatProperties", "imageFormatProperties", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceImageFormatInfo2(const VkPhysicalDeviceImageFormatInfo2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormat(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageType(object.type, settings, "VkImageType", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageTiling(object.tiling, settings, "VkImageTiling", "tiling", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageUsageFlags(object.usage, settings, "VkImageUsageFlags", "usage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageCreateFlags(object.flags, settings, "VkImageCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkQueueFamilyProperties2(const VkQueueFamilyProperties2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkQueueFamilyProperties(object.queueFamilyProperties, settings, "VkQueueFamilyProperties", "queueFamilyProperties", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceMemoryProperties2(const VkPhysicalDeviceMemoryProperties2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + ApiDumpInstance::current().setMemoryHeapCount(object.memoryProperties.memoryHeapCount); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPhysicalDeviceMemoryProperties(object.memoryProperties, settings, "VkPhysicalDeviceMemoryProperties", "memoryProperties", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSparseImageFormatProperties2(const VkSparseImageFormatProperties2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSparseImageFormatProperties(object.properties, settings, "VkSparseImageFormatProperties", "properties", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceSparseImageFormatInfo2(const VkPhysicalDeviceSparseImageFormatInfo2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormat(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageType(object.type, settings, "VkImageType", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSampleCountFlagBits(object.samples, settings, "VkSampleCountFlagBits", "samples", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageUsageFlags(object.usage, settings, "VkImageUsageFlags", "usage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageTiling(object.tiling, settings, "VkImageTiling", "tiling", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImageViewUsageCreateInfo(const VkImageViewUsageCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageUsageFlags(object.usage, settings, "VkImageUsageFlags", "usage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceProtectedMemoryFeatures(const VkPhysicalDeviceProtectedMemoryFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.protectedMemory, settings, "VkBool32", "protectedMemory", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceProtectedMemoryProperties(const VkPhysicalDeviceProtectedMemoryProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.protectedNoFault, settings, "VkBool32", "protectedNoFault", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDeviceQueueInfo2(const VkDeviceQueueInfo2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceQueueCreateFlags(object.flags, settings, "VkDeviceQueueCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.queueIndex, settings, "uint32_t", "queueIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkProtectedSubmitInfo(const VkProtectedSubmitInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.protectedSubmit, settings, "VkBool32", "protectedSubmit", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBindImagePlaneMemoryInfo(const VkBindImagePlaneMemoryInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageAspectFlagBits(object.planeAspect, settings, "VkImageAspectFlagBits", "planeAspect", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImagePlaneMemoryRequirementsInfo(const VkImagePlaneMemoryRequirementsInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageAspectFlagBits(object.planeAspect, settings, "VkImageAspectFlagBits", "planeAspect", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkExternalMemoryProperties(const VkExternalMemoryProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkExternalMemoryFeatureFlags(object.externalMemoryFeatures, settings, "VkExternalMemoryFeatureFlags", "externalMemoryFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalMemoryHandleTypeFlags(object.exportFromImportedHandleTypes, settings, "VkExternalMemoryHandleTypeFlags", "exportFromImportedHandleTypes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalMemoryHandleTypeFlags(object.compatibleHandleTypes, settings, "VkExternalMemoryHandleTypeFlags", "compatibleHandleTypes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceExternalImageFormatInfo(const VkPhysicalDeviceExternalImageFormatInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalMemoryHandleTypeFlagBits(object.handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkExternalImageFormatProperties(const VkExternalImageFormatProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalMemoryProperties(object.externalMemoryProperties, settings, "VkExternalMemoryProperties", "externalMemoryProperties", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceExternalBufferInfo(const VkPhysicalDeviceExternalBufferInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBufferCreateFlags(object.flags, settings, "VkBufferCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBufferUsageFlags(object.usage, settings, "VkBufferUsageFlags", "usage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalMemoryHandleTypeFlagBits(object.handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkExternalBufferProperties(const VkExternalBufferProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalMemoryProperties(object.externalMemoryProperties, settings, "VkExternalMemoryProperties", "externalMemoryProperties", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceIDProperties(const VkPhysicalDeviceIDProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.deviceUUID, VK_UUID_SIZE, settings, "uint8_t[VK_UUID_SIZE]", "deviceUUID", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.driverUUID, VK_UUID_SIZE, settings, "uint8_t[VK_UUID_SIZE]", "driverUUID", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.deviceLUID, VK_LUID_SIZE, settings, "uint8_t[VK_LUID_SIZE]", "deviceLUID", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.deviceNodeMask, settings, "uint32_t", "deviceNodeMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.deviceLUIDValid, settings, "VkBool32", "deviceLUIDValid", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkExternalMemoryImageCreateInfo(const VkExternalMemoryImageCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalMemoryHandleTypeFlags(object.handleTypes, settings, "VkExternalMemoryHandleTypeFlags", "handleTypes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkExternalMemoryBufferCreateInfo(const VkExternalMemoryBufferCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalMemoryHandleTypeFlags(object.handleTypes, settings, "VkExternalMemoryHandleTypeFlags", "handleTypes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkExportMemoryAllocateInfo(const VkExportMemoryAllocateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalMemoryHandleTypeFlags(object.handleTypes, settings, "VkExternalMemoryHandleTypeFlags", "handleTypes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceExternalFenceInfo(const VkPhysicalDeviceExternalFenceInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalFenceHandleTypeFlagBits(object.handleType, settings, "VkExternalFenceHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkExternalFenceProperties(const VkExternalFenceProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalFenceHandleTypeFlags(object.exportFromImportedHandleTypes, settings, "VkExternalFenceHandleTypeFlags", "exportFromImportedHandleTypes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalFenceHandleTypeFlags(object.compatibleHandleTypes, settings, "VkExternalFenceHandleTypeFlags", "compatibleHandleTypes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalFenceFeatureFlags(object.externalFenceFeatures, settings, "VkExternalFenceFeatureFlags", "externalFenceFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkExportFenceCreateInfo(const VkExportFenceCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalFenceHandleTypeFlags(object.handleTypes, settings, "VkExternalFenceHandleTypeFlags", "handleTypes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkExportSemaphoreCreateInfo(const VkExportSemaphoreCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalSemaphoreHandleTypeFlags(object.handleTypes, settings, "VkExternalSemaphoreHandleTypeFlags", "handleTypes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceExternalSemaphoreInfo(const VkPhysicalDeviceExternalSemaphoreInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalSemaphoreHandleTypeFlagBits(object.handleType, settings, "VkExternalSemaphoreHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkExternalSemaphoreProperties(const VkExternalSemaphoreProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalSemaphoreHandleTypeFlags(object.exportFromImportedHandleTypes, settings, "VkExternalSemaphoreHandleTypeFlags", "exportFromImportedHandleTypes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalSemaphoreHandleTypeFlags(object.compatibleHandleTypes, settings, "VkExternalSemaphoreHandleTypeFlags", "compatibleHandleTypes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalSemaphoreFeatureFlags(object.externalSemaphoreFeatures, settings, "VkExternalSemaphoreFeatureFlags", "externalSemaphoreFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceSubgroupProperties(const VkPhysicalDeviceSubgroupProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.subgroupSize, settings, "uint32_t", "subgroupSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkShaderStageFlags(object.supportedStages, settings, "VkShaderStageFlags", "supportedStages", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSubgroupFeatureFlags(object.supportedOperations, settings, "VkSubgroupFeatureFlags", "supportedOperations", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.quadOperationsInAllStages, settings, "VkBool32", "quadOperationsInAllStages", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDevice16BitStorageFeatures(const VkPhysicalDevice16BitStorageFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.storageBuffer16BitAccess, settings, "VkBool32", "storageBuffer16BitAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.uniformAndStorageBuffer16BitAccess, settings, "VkBool32", "uniformAndStorageBuffer16BitAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.storagePushConstant16, settings, "VkBool32", "storagePushConstant16", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.storageInputOutput16, settings, "VkBool32", "storageInputOutput16", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceVariablePointersFeatures(const VkPhysicalDeviceVariablePointersFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.variablePointersStorageBuffer, settings, "VkBool32", "variablePointersStorageBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.variablePointers, settings, "VkBool32", "variablePointers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDescriptorUpdateTemplateEntry(const VkDescriptorUpdateTemplateEntry& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.dstBinding, settings, "uint32_t", "dstBinding", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dstArrayElement, settings, "uint32_t", "dstArrayElement", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorCount, settings, "uint32_t", "descriptorCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDescriptorType(object.descriptorType, settings, "VkDescriptorType", "descriptorType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.offset, settings, "size_t", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.stride, settings, "size_t", "stride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDescriptorUpdateTemplateCreateInfo(const VkDescriptorUpdateTemplateCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDescriptorUpdateTemplateCreateFlags(object.flags, settings, "VkDescriptorUpdateTemplateCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorUpdateEntryCount, settings, "uint32_t", "descriptorUpdateEntryCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pDescriptorUpdateEntries, object.descriptorUpdateEntryCount, settings, "const VkDescriptorUpdateTemplateEntry*", "pDescriptorUpdateEntries", "const VkDescriptorUpdateTemplateEntry", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorUpdateTemplateEntry); + dump_separate_members(settings); + dump_VkDescriptorUpdateTemplateType(object.templateType, settings, "VkDescriptorUpdateTemplateType", "templateType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDescriptorSetLayout(object.descriptorSetLayout, settings, "VkDescriptorSetLayout", "descriptorSetLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineBindPoint(object.pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineLayout(object.pipelineLayout, settings, "VkPipelineLayout", "pipelineLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.set, settings, "uint32_t", "set", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceMaintenance3Properties(const VkPhysicalDeviceMaintenance3Properties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPerSetDescriptors, settings, "uint32_t", "maxPerSetDescriptors", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxMemoryAllocationSize, settings, "VkDeviceSize", "maxMemoryAllocationSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDescriptorSetLayoutSupport(const VkDescriptorSetLayoutSupport& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.supported, settings, "VkBool32", "supported", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSamplerYcbcrConversionCreateInfo(const VkSamplerYcbcrConversionCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormat(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSamplerYcbcrModelConversion(object.ycbcrModel, settings, "VkSamplerYcbcrModelConversion", "ycbcrModel", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSamplerYcbcrRange(object.ycbcrRange, settings, "VkSamplerYcbcrRange", "ycbcrRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkComponentMapping(object.components, settings, "VkComponentMapping", "components", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkChromaLocation(object.xChromaOffset, settings, "VkChromaLocation", "xChromaOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkChromaLocation(object.yChromaOffset, settings, "VkChromaLocation", "yChromaOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFilter(object.chromaFilter, settings, "VkFilter", "chromaFilter", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.forceExplicitReconstruction, settings, "VkBool32", "forceExplicitReconstruction", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSamplerYcbcrConversionInfo(const VkSamplerYcbcrConversionInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSamplerYcbcrConversion(object.conversion, settings, "VkSamplerYcbcrConversion", "conversion", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceSamplerYcbcrConversionFeatures(const VkPhysicalDeviceSamplerYcbcrConversionFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.samplerYcbcrConversion, settings, "VkBool32", "samplerYcbcrConversion", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSamplerYcbcrConversionImageFormatProperties(const VkSamplerYcbcrConversionImageFormatProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.combinedImageSamplerDescriptorCount, settings, "uint32_t", "combinedImageSamplerDescriptorCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDeviceGroupRenderPassBeginInfo(const VkDeviceGroupRenderPassBeginInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.deviceMask, settings, "uint32_t", "deviceMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.deviceRenderAreaCount, settings, "uint32_t", "deviceRenderAreaCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pDeviceRenderAreas, object.deviceRenderAreaCount, settings, "const VkRect2D*", "pDeviceRenderAreas", "const VkRect2D", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkRect2D); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDevicePointClippingProperties(const VkPhysicalDevicePointClippingProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPointClippingBehavior(object.pointClippingBehavior, settings, "VkPointClippingBehavior", "pointClippingBehavior", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkInputAttachmentAspectReference(const VkInputAttachmentAspectReference& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.subpass, settings, "uint32_t", "subpass", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.inputAttachmentIndex, settings, "uint32_t", "inputAttachmentIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageAspectFlags(object.aspectMask, settings, "VkImageAspectFlags", "aspectMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkRenderPassInputAttachmentAspectCreateInfo(const VkRenderPassInputAttachmentAspectCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.aspectReferenceCount, settings, "uint32_t", "aspectReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pAspectReferences, object.aspectReferenceCount, settings, "const VkInputAttachmentAspectReference*", "pAspectReferences", "const VkInputAttachmentAspectReference", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkInputAttachmentAspectReference); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineTessellationDomainOriginStateCreateInfo(const VkPipelineTessellationDomainOriginStateCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkTessellationDomainOrigin(object.domainOrigin, settings, "VkTessellationDomainOrigin", "domainOrigin", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkRenderPassMultiviewCreateInfo(const VkRenderPassMultiviewCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.subpassCount, settings, "uint32_t", "subpassCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pViewMasks, object.subpassCount, settings, "const uint32_t*", "pViewMasks", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.dependencyCount, settings, "uint32_t", "dependencyCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pViewOffsets, object.dependencyCount, settings, "const int32_t*", "pViewOffsets", "const int32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.correlationMaskCount, settings, "uint32_t", "correlationMaskCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pCorrelationMasks, object.correlationMaskCount, settings, "const uint32_t*", "pCorrelationMasks", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceMultiviewFeatures(const VkPhysicalDeviceMultiviewFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.multiview, settings, "VkBool32", "multiview", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.multiviewGeometryShader, settings, "VkBool32", "multiviewGeometryShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.multiviewTessellationShader, settings, "VkBool32", "multiviewTessellationShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceMultiviewProperties(const VkPhysicalDeviceMultiviewProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxMultiviewViewCount, settings, "uint32_t", "maxMultiviewViewCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxMultiviewInstanceIndex, settings, "uint32_t", "maxMultiviewInstanceIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderDrawParametersFeatures(const VkPhysicalDeviceShaderDrawParametersFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderDrawParameters, settings, "VkBool32", "shaderDrawParameters", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceVulkan11Features(const VkPhysicalDeviceVulkan11Features& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.storageBuffer16BitAccess, settings, "VkBool32", "storageBuffer16BitAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.uniformAndStorageBuffer16BitAccess, settings, "VkBool32", "uniformAndStorageBuffer16BitAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.storagePushConstant16, settings, "VkBool32", "storagePushConstant16", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.storageInputOutput16, settings, "VkBool32", "storageInputOutput16", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.multiview, settings, "VkBool32", "multiview", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.multiviewGeometryShader, settings, "VkBool32", "multiviewGeometryShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.multiviewTessellationShader, settings, "VkBool32", "multiviewTessellationShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.variablePointersStorageBuffer, settings, "VkBool32", "variablePointersStorageBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.variablePointers, settings, "VkBool32", "variablePointers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.protectedMemory, settings, "VkBool32", "protectedMemory", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.samplerYcbcrConversion, settings, "VkBool32", "samplerYcbcrConversion", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderDrawParameters, settings, "VkBool32", "shaderDrawParameters", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceVulkan11Properties(const VkPhysicalDeviceVulkan11Properties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.deviceUUID, VK_UUID_SIZE, settings, "uint8_t[VK_UUID_SIZE]", "deviceUUID", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.driverUUID, VK_UUID_SIZE, settings, "uint8_t[VK_UUID_SIZE]", "driverUUID", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.deviceLUID, VK_LUID_SIZE, settings, "uint8_t[VK_LUID_SIZE]", "deviceLUID", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.deviceNodeMask, settings, "uint32_t", "deviceNodeMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.deviceLUIDValid, settings, "VkBool32", "deviceLUIDValid", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.subgroupSize, settings, "uint32_t", "subgroupSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkShaderStageFlags(object.subgroupSupportedStages, settings, "VkShaderStageFlags", "subgroupSupportedStages", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSubgroupFeatureFlags(object.subgroupSupportedOperations, settings, "VkSubgroupFeatureFlags", "subgroupSupportedOperations", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.subgroupQuadOperationsInAllStages, settings, "VkBool32", "subgroupQuadOperationsInAllStages", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPointClippingBehavior(object.pointClippingBehavior, settings, "VkPointClippingBehavior", "pointClippingBehavior", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxMultiviewViewCount, settings, "uint32_t", "maxMultiviewViewCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxMultiviewInstanceIndex, settings, "uint32_t", "maxMultiviewInstanceIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.protectedNoFault, settings, "VkBool32", "protectedNoFault", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPerSetDescriptors, settings, "uint32_t", "maxPerSetDescriptors", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxMemoryAllocationSize, settings, "VkDeviceSize", "maxMemoryAllocationSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceVulkan12Features(const VkPhysicalDeviceVulkan12Features& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.samplerMirrorClampToEdge, settings, "VkBool32", "samplerMirrorClampToEdge", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.drawIndirectCount, settings, "VkBool32", "drawIndirectCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.storageBuffer8BitAccess, settings, "VkBool32", "storageBuffer8BitAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.uniformAndStorageBuffer8BitAccess, settings, "VkBool32", "uniformAndStorageBuffer8BitAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.storagePushConstant8, settings, "VkBool32", "storagePushConstant8", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderBufferInt64Atomics, settings, "VkBool32", "shaderBufferInt64Atomics", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderSharedInt64Atomics, settings, "VkBool32", "shaderSharedInt64Atomics", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderFloat16, settings, "VkBool32", "shaderFloat16", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderInt8, settings, "VkBool32", "shaderInt8", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorIndexing, settings, "VkBool32", "descriptorIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderInputAttachmentArrayDynamicIndexing, settings, "VkBool32", "shaderInputAttachmentArrayDynamicIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderUniformTexelBufferArrayDynamicIndexing, settings, "VkBool32", "shaderUniformTexelBufferArrayDynamicIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderStorageTexelBufferArrayDynamicIndexing, settings, "VkBool32", "shaderStorageTexelBufferArrayDynamicIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderUniformBufferArrayNonUniformIndexing, settings, "VkBool32", "shaderUniformBufferArrayNonUniformIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderSampledImageArrayNonUniformIndexing, settings, "VkBool32", "shaderSampledImageArrayNonUniformIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderStorageBufferArrayNonUniformIndexing, settings, "VkBool32", "shaderStorageBufferArrayNonUniformIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderStorageImageArrayNonUniformIndexing, settings, "VkBool32", "shaderStorageImageArrayNonUniformIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderInputAttachmentArrayNonUniformIndexing, settings, "VkBool32", "shaderInputAttachmentArrayNonUniformIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderUniformTexelBufferArrayNonUniformIndexing, settings, "VkBool32", "shaderUniformTexelBufferArrayNonUniformIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderStorageTexelBufferArrayNonUniformIndexing, settings, "VkBool32", "shaderStorageTexelBufferArrayNonUniformIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorBindingUniformBufferUpdateAfterBind, settings, "VkBool32", "descriptorBindingUniformBufferUpdateAfterBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorBindingSampledImageUpdateAfterBind, settings, "VkBool32", "descriptorBindingSampledImageUpdateAfterBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorBindingStorageImageUpdateAfterBind, settings, "VkBool32", "descriptorBindingStorageImageUpdateAfterBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorBindingStorageBufferUpdateAfterBind, settings, "VkBool32", "descriptorBindingStorageBufferUpdateAfterBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorBindingUniformTexelBufferUpdateAfterBind, settings, "VkBool32", "descriptorBindingUniformTexelBufferUpdateAfterBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorBindingStorageTexelBufferUpdateAfterBind, settings, "VkBool32", "descriptorBindingStorageTexelBufferUpdateAfterBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorBindingUpdateUnusedWhilePending, settings, "VkBool32", "descriptorBindingUpdateUnusedWhilePending", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorBindingPartiallyBound, settings, "VkBool32", "descriptorBindingPartiallyBound", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorBindingVariableDescriptorCount, settings, "VkBool32", "descriptorBindingVariableDescriptorCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.runtimeDescriptorArray, settings, "VkBool32", "runtimeDescriptorArray", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.samplerFilterMinmax, settings, "VkBool32", "samplerFilterMinmax", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.scalarBlockLayout, settings, "VkBool32", "scalarBlockLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.imagelessFramebuffer, settings, "VkBool32", "imagelessFramebuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.uniformBufferStandardLayout, settings, "VkBool32", "uniformBufferStandardLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderSubgroupExtendedTypes, settings, "VkBool32", "shaderSubgroupExtendedTypes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.separateDepthStencilLayouts, settings, "VkBool32", "separateDepthStencilLayouts", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.hostQueryReset, settings, "VkBool32", "hostQueryReset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.timelineSemaphore, settings, "VkBool32", "timelineSemaphore", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bufferDeviceAddress, settings, "VkBool32", "bufferDeviceAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bufferDeviceAddressCaptureReplay, settings, "VkBool32", "bufferDeviceAddressCaptureReplay", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bufferDeviceAddressMultiDevice, settings, "VkBool32", "bufferDeviceAddressMultiDevice", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vulkanMemoryModel, settings, "VkBool32", "vulkanMemoryModel", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vulkanMemoryModelDeviceScope, settings, "VkBool32", "vulkanMemoryModelDeviceScope", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vulkanMemoryModelAvailabilityVisibilityChains, settings, "VkBool32", "vulkanMemoryModelAvailabilityVisibilityChains", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderOutputViewportIndex, settings, "VkBool32", "shaderOutputViewportIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderOutputLayer, settings, "VkBool32", "shaderOutputLayer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.subgroupBroadcastDynamicId, settings, "VkBool32", "subgroupBroadcastDynamicId", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkConformanceVersion(const VkConformanceVersion& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.major, settings, "uint8_t", "major", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minor, settings, "uint8_t", "minor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.subminor, settings, "uint8_t", "subminor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.patch, settings, "uint8_t", "patch", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceVulkan12Properties(const VkPhysicalDeviceVulkan12Properties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDriverId(object.driverID, settings, "VkDriverId", "driverID", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_char(object.driverName, settings, "char[VK_MAX_DRIVER_NAME_SIZE]", "driverName", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_char(object.driverInfo, settings, "char[VK_MAX_DRIVER_INFO_SIZE]", "driverInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkConformanceVersion(object.conformanceVersion, settings, "VkConformanceVersion", "conformanceVersion", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkShaderFloatControlsIndependence(object.denormBehaviorIndependence, settings, "VkShaderFloatControlsIndependence", "denormBehaviorIndependence", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkShaderFloatControlsIndependence(object.roundingModeIndependence, settings, "VkShaderFloatControlsIndependence", "roundingModeIndependence", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderSignedZeroInfNanPreserveFloat16, settings, "VkBool32", "shaderSignedZeroInfNanPreserveFloat16", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderSignedZeroInfNanPreserveFloat32, settings, "VkBool32", "shaderSignedZeroInfNanPreserveFloat32", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderSignedZeroInfNanPreserveFloat64, settings, "VkBool32", "shaderSignedZeroInfNanPreserveFloat64", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderDenormPreserveFloat16, settings, "VkBool32", "shaderDenormPreserveFloat16", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderDenormPreserveFloat32, settings, "VkBool32", "shaderDenormPreserveFloat32", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderDenormPreserveFloat64, settings, "VkBool32", "shaderDenormPreserveFloat64", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderDenormFlushToZeroFloat16, settings, "VkBool32", "shaderDenormFlushToZeroFloat16", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderDenormFlushToZeroFloat32, settings, "VkBool32", "shaderDenormFlushToZeroFloat32", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderDenormFlushToZeroFloat64, settings, "VkBool32", "shaderDenormFlushToZeroFloat64", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderRoundingModeRTEFloat16, settings, "VkBool32", "shaderRoundingModeRTEFloat16", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderRoundingModeRTEFloat32, settings, "VkBool32", "shaderRoundingModeRTEFloat32", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderRoundingModeRTEFloat64, settings, "VkBool32", "shaderRoundingModeRTEFloat64", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderRoundingModeRTZFloat16, settings, "VkBool32", "shaderRoundingModeRTZFloat16", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderRoundingModeRTZFloat32, settings, "VkBool32", "shaderRoundingModeRTZFloat32", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderRoundingModeRTZFloat64, settings, "VkBool32", "shaderRoundingModeRTZFloat64", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxUpdateAfterBindDescriptorsInAllPools, settings, "uint32_t", "maxUpdateAfterBindDescriptorsInAllPools", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderUniformBufferArrayNonUniformIndexingNative, settings, "VkBool32", "shaderUniformBufferArrayNonUniformIndexingNative", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderSampledImageArrayNonUniformIndexingNative, settings, "VkBool32", "shaderSampledImageArrayNonUniformIndexingNative", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderStorageBufferArrayNonUniformIndexingNative, settings, "VkBool32", "shaderStorageBufferArrayNonUniformIndexingNative", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderStorageImageArrayNonUniformIndexingNative, settings, "VkBool32", "shaderStorageImageArrayNonUniformIndexingNative", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderInputAttachmentArrayNonUniformIndexingNative, settings, "VkBool32", "shaderInputAttachmentArrayNonUniformIndexingNative", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.robustBufferAccessUpdateAfterBind, settings, "VkBool32", "robustBufferAccessUpdateAfterBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.quadDivergentImplicitLod, settings, "VkBool32", "quadDivergentImplicitLod", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPerStageDescriptorUpdateAfterBindSamplers, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindSamplers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPerStageDescriptorUpdateAfterBindUniformBuffers, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindUniformBuffers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPerStageDescriptorUpdateAfterBindStorageBuffers, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindStorageBuffers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPerStageDescriptorUpdateAfterBindSampledImages, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindSampledImages", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPerStageDescriptorUpdateAfterBindStorageImages, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindStorageImages", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPerStageDescriptorUpdateAfterBindInputAttachments, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindInputAttachments", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPerStageUpdateAfterBindResources, settings, "uint32_t", "maxPerStageUpdateAfterBindResources", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDescriptorSetUpdateAfterBindSamplers, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindSamplers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDescriptorSetUpdateAfterBindUniformBuffers, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindUniformBuffers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindUniformBuffersDynamic", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDescriptorSetUpdateAfterBindStorageBuffers, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindStorageBuffers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindStorageBuffersDynamic", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDescriptorSetUpdateAfterBindSampledImages, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindSampledImages", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDescriptorSetUpdateAfterBindStorageImages, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindStorageImages", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDescriptorSetUpdateAfterBindInputAttachments, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindInputAttachments", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkResolveModeFlags(object.supportedDepthResolveModes, settings, "VkResolveModeFlags", "supportedDepthResolveModes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkResolveModeFlags(object.supportedStencilResolveModes, settings, "VkResolveModeFlags", "supportedStencilResolveModes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.independentResolveNone, settings, "VkBool32", "independentResolveNone", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.independentResolve, settings, "VkBool32", "independentResolve", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.filterMinmaxSingleComponentFormats, settings, "VkBool32", "filterMinmaxSingleComponentFormats", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.filterMinmaxImageComponentMapping, settings, "VkBool32", "filterMinmaxImageComponentMapping", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxTimelineSemaphoreValueDifference, settings, "uint64_t", "maxTimelineSemaphoreValueDifference", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSampleCountFlags(object.framebufferIntegerColorSampleCounts, settings, "VkSampleCountFlags", "framebufferIntegerColorSampleCounts", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImageFormatListCreateInfo(const VkImageFormatListCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.viewFormatCount, settings, "uint32_t", "viewFormatCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pViewFormats, object.viewFormatCount, settings, "const VkFormat*", "pViewFormats", "const VkFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkFormat); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceDriverProperties(const VkPhysicalDeviceDriverProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDriverId(object.driverID, settings, "VkDriverId", "driverID", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_char(object.driverName, settings, "char[VK_MAX_DRIVER_NAME_SIZE]", "driverName", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_char(object.driverInfo, settings, "char[VK_MAX_DRIVER_INFO_SIZE]", "driverInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkConformanceVersion(object.conformanceVersion, settings, "VkConformanceVersion", "conformanceVersion", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceVulkanMemoryModelFeatures(const VkPhysicalDeviceVulkanMemoryModelFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vulkanMemoryModel, settings, "VkBool32", "vulkanMemoryModel", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vulkanMemoryModelDeviceScope, settings, "VkBool32", "vulkanMemoryModelDeviceScope", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vulkanMemoryModelAvailabilityVisibilityChains, settings, "VkBool32", "vulkanMemoryModelAvailabilityVisibilityChains", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceHostQueryResetFeatures(const VkPhysicalDeviceHostQueryResetFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.hostQueryReset, settings, "VkBool32", "hostQueryReset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceTimelineSemaphoreFeatures(const VkPhysicalDeviceTimelineSemaphoreFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.timelineSemaphore, settings, "VkBool32", "timelineSemaphore", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceTimelineSemaphoreProperties(const VkPhysicalDeviceTimelineSemaphoreProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxTimelineSemaphoreValueDifference, settings, "uint64_t", "maxTimelineSemaphoreValueDifference", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSemaphoreTypeCreateInfo(const VkSemaphoreTypeCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSemaphoreType(object.semaphoreType, settings, "VkSemaphoreType", "semaphoreType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.initialValue, settings, "uint64_t", "initialValue", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkTimelineSemaphoreSubmitInfo(const VkTimelineSemaphoreSubmitInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.waitSemaphoreValueCount, settings, "uint32_t", "waitSemaphoreValueCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pWaitSemaphoreValues, object.waitSemaphoreValueCount, settings, "const uint64_t*", "pWaitSemaphoreValues", "const uint64_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.signalSemaphoreValueCount, settings, "uint32_t", "signalSemaphoreValueCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pSignalSemaphoreValues, object.signalSemaphoreValueCount, settings, "const uint64_t*", "pSignalSemaphoreValues", "const uint64_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSemaphoreWaitInfo(const VkSemaphoreWaitInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSemaphoreWaitFlags(object.flags, settings, "VkSemaphoreWaitFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.semaphoreCount, settings, "uint32_t", "semaphoreCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pSemaphores, object.semaphoreCount, settings, "const VkSemaphore*", "pSemaphores", "const VkSemaphore", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSemaphore); + dump_separate_members(settings); + dump_pointer_array(object.pValues, object.semaphoreCount, settings, "const uint64_t*", "pValues", "const uint64_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSemaphoreSignalInfo(const VkSemaphoreSignalInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSemaphore(object.semaphore, settings, "VkSemaphore", "semaphore", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.value, settings, "uint64_t", "value", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceBufferDeviceAddressFeatures(const VkPhysicalDeviceBufferDeviceAddressFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bufferDeviceAddress, settings, "VkBool32", "bufferDeviceAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bufferDeviceAddressCaptureReplay, settings, "VkBool32", "bufferDeviceAddressCaptureReplay", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bufferDeviceAddressMultiDevice, settings, "VkBool32", "bufferDeviceAddressMultiDevice", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBufferDeviceAddressInfo(const VkBufferDeviceAddressInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBuffer(object.buffer, settings, "VkBuffer", "buffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBufferOpaqueCaptureAddressCreateInfo(const VkBufferOpaqueCaptureAddressCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.opaqueCaptureAddress, settings, "uint64_t", "opaqueCaptureAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMemoryOpaqueCaptureAddressAllocateInfo(const VkMemoryOpaqueCaptureAddressAllocateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.opaqueCaptureAddress, settings, "uint64_t", "opaqueCaptureAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDeviceMemoryOpaqueCaptureAddressInfo(const VkDeviceMemoryOpaqueCaptureAddressInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceMemory(object.memory, settings, "VkDeviceMemory", "memory", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDevice8BitStorageFeatures(const VkPhysicalDevice8BitStorageFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.storageBuffer8BitAccess, settings, "VkBool32", "storageBuffer8BitAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.uniformAndStorageBuffer8BitAccess, settings, "VkBool32", "uniformAndStorageBuffer8BitAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.storagePushConstant8, settings, "VkBool32", "storagePushConstant8", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderAtomicInt64Features(const VkPhysicalDeviceShaderAtomicInt64Features& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderBufferInt64Atomics, settings, "VkBool32", "shaderBufferInt64Atomics", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderSharedInt64Atomics, settings, "VkBool32", "shaderSharedInt64Atomics", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderFloat16Int8Features(const VkPhysicalDeviceShaderFloat16Int8Features& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderFloat16, settings, "VkBool32", "shaderFloat16", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderInt8, settings, "VkBool32", "shaderInt8", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceFloatControlsProperties(const VkPhysicalDeviceFloatControlsProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkShaderFloatControlsIndependence(object.denormBehaviorIndependence, settings, "VkShaderFloatControlsIndependence", "denormBehaviorIndependence", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkShaderFloatControlsIndependence(object.roundingModeIndependence, settings, "VkShaderFloatControlsIndependence", "roundingModeIndependence", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderSignedZeroInfNanPreserveFloat16, settings, "VkBool32", "shaderSignedZeroInfNanPreserveFloat16", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderSignedZeroInfNanPreserveFloat32, settings, "VkBool32", "shaderSignedZeroInfNanPreserveFloat32", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderSignedZeroInfNanPreserveFloat64, settings, "VkBool32", "shaderSignedZeroInfNanPreserveFloat64", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderDenormPreserveFloat16, settings, "VkBool32", "shaderDenormPreserveFloat16", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderDenormPreserveFloat32, settings, "VkBool32", "shaderDenormPreserveFloat32", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderDenormPreserveFloat64, settings, "VkBool32", "shaderDenormPreserveFloat64", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderDenormFlushToZeroFloat16, settings, "VkBool32", "shaderDenormFlushToZeroFloat16", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderDenormFlushToZeroFloat32, settings, "VkBool32", "shaderDenormFlushToZeroFloat32", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderDenormFlushToZeroFloat64, settings, "VkBool32", "shaderDenormFlushToZeroFloat64", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderRoundingModeRTEFloat16, settings, "VkBool32", "shaderRoundingModeRTEFloat16", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderRoundingModeRTEFloat32, settings, "VkBool32", "shaderRoundingModeRTEFloat32", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderRoundingModeRTEFloat64, settings, "VkBool32", "shaderRoundingModeRTEFloat64", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderRoundingModeRTZFloat16, settings, "VkBool32", "shaderRoundingModeRTZFloat16", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderRoundingModeRTZFloat32, settings, "VkBool32", "shaderRoundingModeRTZFloat32", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderRoundingModeRTZFloat64, settings, "VkBool32", "shaderRoundingModeRTZFloat64", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDescriptorSetLayoutBindingFlagsCreateInfo(const VkDescriptorSetLayoutBindingFlagsCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bindingCount, settings, "uint32_t", "bindingCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pBindingFlags, object.bindingCount, settings, "const VkDescriptorBindingFlags*", "pBindingFlags", "const VkDescriptorBindingFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorBindingFlags); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceDescriptorIndexingFeatures(const VkPhysicalDeviceDescriptorIndexingFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderInputAttachmentArrayDynamicIndexing, settings, "VkBool32", "shaderInputAttachmentArrayDynamicIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderUniformTexelBufferArrayDynamicIndexing, settings, "VkBool32", "shaderUniformTexelBufferArrayDynamicIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderStorageTexelBufferArrayDynamicIndexing, settings, "VkBool32", "shaderStorageTexelBufferArrayDynamicIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderUniformBufferArrayNonUniformIndexing, settings, "VkBool32", "shaderUniformBufferArrayNonUniformIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderSampledImageArrayNonUniformIndexing, settings, "VkBool32", "shaderSampledImageArrayNonUniformIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderStorageBufferArrayNonUniformIndexing, settings, "VkBool32", "shaderStorageBufferArrayNonUniformIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderStorageImageArrayNonUniformIndexing, settings, "VkBool32", "shaderStorageImageArrayNonUniformIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderInputAttachmentArrayNonUniformIndexing, settings, "VkBool32", "shaderInputAttachmentArrayNonUniformIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderUniformTexelBufferArrayNonUniformIndexing, settings, "VkBool32", "shaderUniformTexelBufferArrayNonUniformIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderStorageTexelBufferArrayNonUniformIndexing, settings, "VkBool32", "shaderStorageTexelBufferArrayNonUniformIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorBindingUniformBufferUpdateAfterBind, settings, "VkBool32", "descriptorBindingUniformBufferUpdateAfterBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorBindingSampledImageUpdateAfterBind, settings, "VkBool32", "descriptorBindingSampledImageUpdateAfterBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorBindingStorageImageUpdateAfterBind, settings, "VkBool32", "descriptorBindingStorageImageUpdateAfterBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorBindingStorageBufferUpdateAfterBind, settings, "VkBool32", "descriptorBindingStorageBufferUpdateAfterBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorBindingUniformTexelBufferUpdateAfterBind, settings, "VkBool32", "descriptorBindingUniformTexelBufferUpdateAfterBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorBindingStorageTexelBufferUpdateAfterBind, settings, "VkBool32", "descriptorBindingStorageTexelBufferUpdateAfterBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorBindingUpdateUnusedWhilePending, settings, "VkBool32", "descriptorBindingUpdateUnusedWhilePending", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorBindingPartiallyBound, settings, "VkBool32", "descriptorBindingPartiallyBound", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorBindingVariableDescriptorCount, settings, "VkBool32", "descriptorBindingVariableDescriptorCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.runtimeDescriptorArray, settings, "VkBool32", "runtimeDescriptorArray", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceDescriptorIndexingProperties(const VkPhysicalDeviceDescriptorIndexingProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxUpdateAfterBindDescriptorsInAllPools, settings, "uint32_t", "maxUpdateAfterBindDescriptorsInAllPools", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderUniformBufferArrayNonUniformIndexingNative, settings, "VkBool32", "shaderUniformBufferArrayNonUniformIndexingNative", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderSampledImageArrayNonUniformIndexingNative, settings, "VkBool32", "shaderSampledImageArrayNonUniformIndexingNative", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderStorageBufferArrayNonUniformIndexingNative, settings, "VkBool32", "shaderStorageBufferArrayNonUniformIndexingNative", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderStorageImageArrayNonUniformIndexingNative, settings, "VkBool32", "shaderStorageImageArrayNonUniformIndexingNative", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderInputAttachmentArrayNonUniformIndexingNative, settings, "VkBool32", "shaderInputAttachmentArrayNonUniformIndexingNative", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.robustBufferAccessUpdateAfterBind, settings, "VkBool32", "robustBufferAccessUpdateAfterBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.quadDivergentImplicitLod, settings, "VkBool32", "quadDivergentImplicitLod", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPerStageDescriptorUpdateAfterBindSamplers, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindSamplers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPerStageDescriptorUpdateAfterBindUniformBuffers, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindUniformBuffers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPerStageDescriptorUpdateAfterBindStorageBuffers, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindStorageBuffers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPerStageDescriptorUpdateAfterBindSampledImages, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindSampledImages", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPerStageDescriptorUpdateAfterBindStorageImages, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindStorageImages", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPerStageDescriptorUpdateAfterBindInputAttachments, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindInputAttachments", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPerStageUpdateAfterBindResources, settings, "uint32_t", "maxPerStageUpdateAfterBindResources", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDescriptorSetUpdateAfterBindSamplers, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindSamplers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDescriptorSetUpdateAfterBindUniformBuffers, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindUniformBuffers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindUniformBuffersDynamic", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDescriptorSetUpdateAfterBindStorageBuffers, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindStorageBuffers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindStorageBuffersDynamic", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDescriptorSetUpdateAfterBindSampledImages, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindSampledImages", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDescriptorSetUpdateAfterBindStorageImages, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindStorageImages", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDescriptorSetUpdateAfterBindInputAttachments, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindInputAttachments", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDescriptorSetVariableDescriptorCountAllocateInfo(const VkDescriptorSetVariableDescriptorCountAllocateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorSetCount, settings, "uint32_t", "descriptorSetCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pDescriptorCounts, object.descriptorSetCount, settings, "const uint32_t*", "pDescriptorCounts", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDescriptorSetVariableDescriptorCountLayoutSupport(const VkDescriptorSetVariableDescriptorCountLayoutSupport& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxVariableDescriptorCount, settings, "uint32_t", "maxVariableDescriptorCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceScalarBlockLayoutFeatures(const VkPhysicalDeviceScalarBlockLayoutFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.scalarBlockLayout, settings, "VkBool32", "scalarBlockLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSamplerReductionModeCreateInfo(const VkSamplerReductionModeCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSamplerReductionMode(object.reductionMode, settings, "VkSamplerReductionMode", "reductionMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceSamplerFilterMinmaxProperties(const VkPhysicalDeviceSamplerFilterMinmaxProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.filterMinmaxSingleComponentFormats, settings, "VkBool32", "filterMinmaxSingleComponentFormats", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.filterMinmaxImageComponentMapping, settings, "VkBool32", "filterMinmaxImageComponentMapping", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.uniformBufferStandardLayout, settings, "VkBool32", "uniformBufferStandardLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderSubgroupExtendedTypes, settings, "VkBool32", "shaderSubgroupExtendedTypes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAttachmentDescription2(const VkAttachmentDescription2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAttachmentDescriptionFlags(object.flags, settings, "VkAttachmentDescriptionFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormat(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSampleCountFlagBits(object.samples, settings, "VkSampleCountFlagBits", "samples", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAttachmentLoadOp(object.loadOp, settings, "VkAttachmentLoadOp", "loadOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAttachmentStoreOp(object.storeOp, settings, "VkAttachmentStoreOp", "storeOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAttachmentLoadOp(object.stencilLoadOp, settings, "VkAttachmentLoadOp", "stencilLoadOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAttachmentStoreOp(object.stencilStoreOp, settings, "VkAttachmentStoreOp", "stencilStoreOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(object.initialLayout, settings, "VkImageLayout", "initialLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(object.finalLayout, settings, "VkImageLayout", "finalLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAttachmentReference2(const VkAttachmentReference2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.attachment, settings, "uint32_t", "attachment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(object.layout, settings, "VkImageLayout", "layout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageAspectFlags(object.aspectMask, settings, "VkImageAspectFlags", "aspectMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSubpassDescription2(const VkSubpassDescription2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSubpassDescriptionFlags(object.flags, settings, "VkSubpassDescriptionFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineBindPoint(object.pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.viewMask, settings, "uint32_t", "viewMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.inputAttachmentCount, settings, "uint32_t", "inputAttachmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pInputAttachments, object.inputAttachmentCount, settings, "const VkAttachmentReference2*", "pInputAttachments", "const VkAttachmentReference2", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkAttachmentReference2); + dump_separate_members(settings); + dump_type(object.colorAttachmentCount, settings, "uint32_t", "colorAttachmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pColorAttachments, object.colorAttachmentCount, settings, "const VkAttachmentReference2*", "pColorAttachments", "const VkAttachmentReference2", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkAttachmentReference2); + dump_separate_members(settings); + dump_pointer_array(object.pResolveAttachments, object.colorAttachmentCount, settings, "const VkAttachmentReference2*", "pResolveAttachments", "const VkAttachmentReference2", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkAttachmentReference2); + dump_separate_members(settings); + dump_pointer(object.pDepthStencilAttachment, settings, "const VkAttachmentReference2*", "pDepthStencilAttachment", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkAttachmentReference2); + dump_separate_members(settings); + dump_type(object.preserveAttachmentCount, settings, "uint32_t", "preserveAttachmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pPreserveAttachments, object.preserveAttachmentCount, settings, "const uint32_t*", "pPreserveAttachments", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSubpassDependency2(const VkSubpassDependency2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.srcSubpass, settings, "uint32_t", "srcSubpass", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dstSubpass, settings, "uint32_t", "dstSubpass", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineStageFlags(object.srcStageMask, settings, "VkPipelineStageFlags", "srcStageMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineStageFlags(object.dstStageMask, settings, "VkPipelineStageFlags", "dstStageMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccessFlags(object.srcAccessMask, settings, "VkAccessFlags", "srcAccessMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccessFlags(object.dstAccessMask, settings, "VkAccessFlags", "dstAccessMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDependencyFlags(object.dependencyFlags, settings, "VkDependencyFlags", "dependencyFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.viewOffset, settings, "int32_t", "viewOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkRenderPassCreateInfo2(const VkRenderPassCreateInfo2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkRenderPassCreateFlags(object.flags, settings, "VkRenderPassCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.attachmentCount, settings, "uint32_t", "attachmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pAttachments, object.attachmentCount, settings, "const VkAttachmentDescription2*", "pAttachments", "const VkAttachmentDescription2", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkAttachmentDescription2); + dump_separate_members(settings); + dump_type(object.subpassCount, settings, "uint32_t", "subpassCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pSubpasses, object.subpassCount, settings, "const VkSubpassDescription2*", "pSubpasses", "const VkSubpassDescription2", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSubpassDescription2); + dump_separate_members(settings); + dump_type(object.dependencyCount, settings, "uint32_t", "dependencyCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pDependencies, object.dependencyCount, settings, "const VkSubpassDependency2*", "pDependencies", "const VkSubpassDependency2", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSubpassDependency2); + dump_separate_members(settings); + dump_type(object.correlatedViewMaskCount, settings, "uint32_t", "correlatedViewMaskCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pCorrelatedViewMasks, object.correlatedViewMaskCount, settings, "const uint32_t*", "pCorrelatedViewMasks", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSubpassBeginInfo(const VkSubpassBeginInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSubpassContents(object.contents, settings, "VkSubpassContents", "contents", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSubpassEndInfo(const VkSubpassEndInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSubpassDescriptionDepthStencilResolve(const VkSubpassDescriptionDepthStencilResolve& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkResolveModeFlagBits(object.depthResolveMode, settings, "VkResolveModeFlagBits", "depthResolveMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkResolveModeFlagBits(object.stencilResolveMode, settings, "VkResolveModeFlagBits", "stencilResolveMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pDepthStencilResolveAttachment, settings, "const VkAttachmentReference2*", "pDepthStencilResolveAttachment", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkAttachmentReference2); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceDepthStencilResolveProperties(const VkPhysicalDeviceDepthStencilResolveProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkResolveModeFlags(object.supportedDepthResolveModes, settings, "VkResolveModeFlags", "supportedDepthResolveModes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkResolveModeFlags(object.supportedStencilResolveModes, settings, "VkResolveModeFlags", "supportedStencilResolveModes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.independentResolveNone, settings, "VkBool32", "independentResolveNone", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.independentResolve, settings, "VkBool32", "independentResolve", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImageStencilUsageCreateInfo(const VkImageStencilUsageCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageUsageFlags(object.stencilUsage, settings, "VkImageUsageFlags", "stencilUsage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceImagelessFramebufferFeatures(const VkPhysicalDeviceImagelessFramebufferFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.imagelessFramebuffer, settings, "VkBool32", "imagelessFramebuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkFramebufferAttachmentImageInfo(const VkFramebufferAttachmentImageInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageCreateFlags(object.flags, settings, "VkImageCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageUsageFlags(object.usage, settings, "VkImageUsageFlags", "usage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.width, settings, "uint32_t", "width", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.height, settings, "uint32_t", "height", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.layerCount, settings, "uint32_t", "layerCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.viewFormatCount, settings, "uint32_t", "viewFormatCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pViewFormats, object.viewFormatCount, settings, "const VkFormat*", "pViewFormats", "const VkFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkFormat); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkFramebufferAttachmentsCreateInfo(const VkFramebufferAttachmentsCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.attachmentImageInfoCount, settings, "uint32_t", "attachmentImageInfoCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pAttachmentImageInfos, object.attachmentImageInfoCount, settings, "const VkFramebufferAttachmentImageInfo*", "pAttachmentImageInfos", "const VkFramebufferAttachmentImageInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkFramebufferAttachmentImageInfo); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkRenderPassAttachmentBeginInfo(const VkRenderPassAttachmentBeginInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.attachmentCount, settings, "uint32_t", "attachmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pAttachments, object.attachmentCount, settings, "const VkImageView*", "pAttachments", "const VkImageView", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkImageView); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.separateDepthStencilLayouts, settings, "VkBool32", "separateDepthStencilLayouts", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAttachmentReferenceStencilLayout(const VkAttachmentReferenceStencilLayout& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(object.stencilLayout, settings, "VkImageLayout", "stencilLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAttachmentDescriptionStencilLayout(const VkAttachmentDescriptionStencilLayout& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(object.stencilInitialLayout, settings, "VkImageLayout", "stencilInitialLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(object.stencilFinalLayout, settings, "VkImageLayout", "stencilFinalLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceVulkan13Features(const VkPhysicalDeviceVulkan13Features& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.robustImageAccess, settings, "VkBool32", "robustImageAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.inlineUniformBlock, settings, "VkBool32", "inlineUniformBlock", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorBindingInlineUniformBlockUpdateAfterBind, settings, "VkBool32", "descriptorBindingInlineUniformBlockUpdateAfterBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pipelineCreationCacheControl, settings, "VkBool32", "pipelineCreationCacheControl", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.privateData, settings, "VkBool32", "privateData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderDemoteToHelperInvocation, settings, "VkBool32", "shaderDemoteToHelperInvocation", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderTerminateInvocation, settings, "VkBool32", "shaderTerminateInvocation", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.subgroupSizeControl, settings, "VkBool32", "subgroupSizeControl", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.computeFullSubgroups, settings, "VkBool32", "computeFullSubgroups", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.synchronization2, settings, "VkBool32", "synchronization2", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.textureCompressionASTC_HDR, settings, "VkBool32", "textureCompressionASTC_HDR", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderZeroInitializeWorkgroupMemory, settings, "VkBool32", "shaderZeroInitializeWorkgroupMemory", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dynamicRendering, settings, "VkBool32", "dynamicRendering", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderIntegerDotProduct, settings, "VkBool32", "shaderIntegerDotProduct", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maintenance4, settings, "VkBool32", "maintenance4", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceVulkan13Properties(const VkPhysicalDeviceVulkan13Properties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minSubgroupSize, settings, "uint32_t", "minSubgroupSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxSubgroupSize, settings, "uint32_t", "maxSubgroupSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxComputeWorkgroupSubgroups, settings, "uint32_t", "maxComputeWorkgroupSubgroups", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkShaderStageFlags(object.requiredSubgroupSizeStages, settings, "VkShaderStageFlags", "requiredSubgroupSizeStages", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxInlineUniformBlockSize, settings, "uint32_t", "maxInlineUniformBlockSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPerStageDescriptorInlineUniformBlocks, settings, "uint32_t", "maxPerStageDescriptorInlineUniformBlocks", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDescriptorSetInlineUniformBlocks, settings, "uint32_t", "maxDescriptorSetInlineUniformBlocks", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDescriptorSetUpdateAfterBindInlineUniformBlocks, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindInlineUniformBlocks", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxInlineUniformTotalSize, settings, "uint32_t", "maxInlineUniformTotalSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProduct8BitUnsignedAccelerated, settings, "VkBool32", "integerDotProduct8BitUnsignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProduct8BitSignedAccelerated, settings, "VkBool32", "integerDotProduct8BitSignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProduct8BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProduct8BitMixedSignednessAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProduct4x8BitPackedUnsignedAccelerated, settings, "VkBool32", "integerDotProduct4x8BitPackedUnsignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProduct4x8BitPackedSignedAccelerated, settings, "VkBool32", "integerDotProduct4x8BitPackedSignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProduct4x8BitPackedMixedSignednessAccelerated, settings, "VkBool32", "integerDotProduct4x8BitPackedMixedSignednessAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProduct16BitUnsignedAccelerated, settings, "VkBool32", "integerDotProduct16BitUnsignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProduct16BitSignedAccelerated, settings, "VkBool32", "integerDotProduct16BitSignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProduct16BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProduct16BitMixedSignednessAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProduct32BitUnsignedAccelerated, settings, "VkBool32", "integerDotProduct32BitUnsignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProduct32BitSignedAccelerated, settings, "VkBool32", "integerDotProduct32BitSignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProduct32BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProduct32BitMixedSignednessAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProduct64BitUnsignedAccelerated, settings, "VkBool32", "integerDotProduct64BitUnsignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProduct64BitSignedAccelerated, settings, "VkBool32", "integerDotProduct64BitSignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProduct64BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProduct64BitMixedSignednessAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating8BitUnsignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProductAccumulatingSaturating8BitSignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating8BitSignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating16BitUnsignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProductAccumulatingSaturating16BitSignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating16BitSignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating32BitUnsignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProductAccumulatingSaturating32BitSignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating32BitSignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating64BitUnsignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProductAccumulatingSaturating64BitSignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating64BitSignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.storageTexelBufferOffsetAlignmentBytes, settings, "VkDeviceSize", "storageTexelBufferOffsetAlignmentBytes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.storageTexelBufferOffsetSingleTexelAlignment, settings, "VkBool32", "storageTexelBufferOffsetSingleTexelAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.uniformTexelBufferOffsetAlignmentBytes, settings, "VkDeviceSize", "uniformTexelBufferOffsetAlignmentBytes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.uniformTexelBufferOffsetSingleTexelAlignment, settings, "VkBool32", "uniformTexelBufferOffsetSingleTexelAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxBufferSize, settings, "VkDeviceSize", "maxBufferSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceToolProperties(const VkPhysicalDeviceToolProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_char(object.name, settings, "char[VK_MAX_EXTENSION_NAME_SIZE]", "name", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_char(object.version, settings, "char[VK_MAX_EXTENSION_NAME_SIZE]", "version", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkToolPurposeFlags(object.purposes, settings, "VkToolPurposeFlags", "purposes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_char(object.description, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "description", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_char(object.layer, settings, "char[VK_MAX_EXTENSION_NAME_SIZE]", "layer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDevicePrivateDataFeatures(const VkPhysicalDevicePrivateDataFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.privateData, settings, "VkBool32", "privateData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDevicePrivateDataCreateInfo(const VkDevicePrivateDataCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.privateDataSlotRequestCount, settings, "uint32_t", "privateDataSlotRequestCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPrivateDataSlotCreateInfo(const VkPrivateDataSlotCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPrivateDataSlotCreateFlags(object.flags, settings, "VkPrivateDataSlotCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMemoryBarrier2(const VkMemoryBarrier2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineStageFlags2(object.srcStageMask, settings, "VkPipelineStageFlags2", "srcStageMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccessFlags2(object.srcAccessMask, settings, "VkAccessFlags2", "srcAccessMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineStageFlags2(object.dstStageMask, settings, "VkPipelineStageFlags2", "dstStageMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccessFlags2(object.dstAccessMask, settings, "VkAccessFlags2", "dstAccessMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBufferMemoryBarrier2(const VkBufferMemoryBarrier2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineStageFlags2(object.srcStageMask, settings, "VkPipelineStageFlags2", "srcStageMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccessFlags2(object.srcAccessMask, settings, "VkAccessFlags2", "srcAccessMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineStageFlags2(object.dstStageMask, settings, "VkPipelineStageFlags2", "dstStageMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccessFlags2(object.dstAccessMask, settings, "VkAccessFlags2", "dstAccessMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.srcQueueFamilyIndex, settings, "uint32_t", "srcQueueFamilyIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dstQueueFamilyIndex, settings, "uint32_t", "dstQueueFamilyIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBuffer(object.buffer, settings, "VkBuffer", "buffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.offset, settings, "VkDeviceSize", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImageMemoryBarrier2(const VkImageMemoryBarrier2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineStageFlags2(object.srcStageMask, settings, "VkPipelineStageFlags2", "srcStageMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccessFlags2(object.srcAccessMask, settings, "VkAccessFlags2", "srcAccessMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineStageFlags2(object.dstStageMask, settings, "VkPipelineStageFlags2", "dstStageMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccessFlags2(object.dstAccessMask, settings, "VkAccessFlags2", "dstAccessMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(object.oldLayout, settings, "VkImageLayout", "oldLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(object.newLayout, settings, "VkImageLayout", "newLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.srcQueueFamilyIndex, settings, "uint32_t", "srcQueueFamilyIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dstQueueFamilyIndex, settings, "uint32_t", "dstQueueFamilyIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImage(object.image, settings, "VkImage", "image", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageSubresourceRange(object.subresourceRange, settings, "VkImageSubresourceRange", "subresourceRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDependencyInfo(const VkDependencyInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDependencyFlags(object.dependencyFlags, settings, "VkDependencyFlags", "dependencyFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.memoryBarrierCount, settings, "uint32_t", "memoryBarrierCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pMemoryBarriers, object.memoryBarrierCount, settings, "const VkMemoryBarrier2*", "pMemoryBarriers", "const VkMemoryBarrier2", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkMemoryBarrier2); + dump_separate_members(settings); + dump_type(object.bufferMemoryBarrierCount, settings, "uint32_t", "bufferMemoryBarrierCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pBufferMemoryBarriers, object.bufferMemoryBarrierCount, settings, "const VkBufferMemoryBarrier2*", "pBufferMemoryBarriers", "const VkBufferMemoryBarrier2", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkBufferMemoryBarrier2); + dump_separate_members(settings); + dump_type(object.imageMemoryBarrierCount, settings, "uint32_t", "imageMemoryBarrierCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pImageMemoryBarriers, object.imageMemoryBarrierCount, settings, "const VkImageMemoryBarrier2*", "pImageMemoryBarriers", "const VkImageMemoryBarrier2", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkImageMemoryBarrier2); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSemaphoreSubmitInfo(const VkSemaphoreSubmitInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSemaphore(object.semaphore, settings, "VkSemaphore", "semaphore", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.value, settings, "uint64_t", "value", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineStageFlags2(object.stageMask, settings, "VkPipelineStageFlags2", "stageMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.deviceIndex, settings, "uint32_t", "deviceIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCommandBufferSubmitInfo(const VkCommandBufferSubmitInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkCommandBuffer(object.commandBuffer, settings, "VkCommandBuffer", "commandBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.deviceMask, settings, "uint32_t", "deviceMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSubmitInfo2(const VkSubmitInfo2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSubmitFlags(object.flags, settings, "VkSubmitFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.waitSemaphoreInfoCount, settings, "uint32_t", "waitSemaphoreInfoCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pWaitSemaphoreInfos, object.waitSemaphoreInfoCount, settings, "const VkSemaphoreSubmitInfo*", "pWaitSemaphoreInfos", "const VkSemaphoreSubmitInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSemaphoreSubmitInfo); + dump_separate_members(settings); + dump_type(object.commandBufferInfoCount, settings, "uint32_t", "commandBufferInfoCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pCommandBufferInfos, object.commandBufferInfoCount, settings, "const VkCommandBufferSubmitInfo*", "pCommandBufferInfos", "const VkCommandBufferSubmitInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkCommandBufferSubmitInfo); + dump_separate_members(settings); + dump_type(object.signalSemaphoreInfoCount, settings, "uint32_t", "signalSemaphoreInfoCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pSignalSemaphoreInfos, object.signalSemaphoreInfoCount, settings, "const VkSemaphoreSubmitInfo*", "pSignalSemaphoreInfos", "const VkSemaphoreSubmitInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSemaphoreSubmitInfo); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceSynchronization2Features(const VkPhysicalDeviceSynchronization2Features& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.synchronization2, settings, "VkBool32", "synchronization2", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBufferCopy2(const VkBufferCopy2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.srcOffset, settings, "VkDeviceSize", "srcOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dstOffset, settings, "VkDeviceSize", "dstOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCopyBufferInfo2(const VkCopyBufferInfo2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBuffer(object.srcBuffer, settings, "VkBuffer", "srcBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBuffer(object.dstBuffer, settings, "VkBuffer", "dstBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.regionCount, settings, "uint32_t", "regionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pRegions, object.regionCount, settings, "const VkBufferCopy2*", "pRegions", "const VkBufferCopy2", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkBufferCopy2); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImageCopy2(const VkImageCopy2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageSubresourceLayers(object.srcSubresource, settings, "VkImageSubresourceLayers", "srcSubresource", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkOffset3D(object.srcOffset, settings, "VkOffset3D", "srcOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageSubresourceLayers(object.dstSubresource, settings, "VkImageSubresourceLayers", "dstSubresource", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkOffset3D(object.dstOffset, settings, "VkOffset3D", "dstOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent3D(object.extent, settings, "VkExtent3D", "extent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCopyImageInfo2(const VkCopyImageInfo2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImage(object.srcImage, settings, "VkImage", "srcImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(object.srcImageLayout, settings, "VkImageLayout", "srcImageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImage(object.dstImage, settings, "VkImage", "dstImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(object.dstImageLayout, settings, "VkImageLayout", "dstImageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.regionCount, settings, "uint32_t", "regionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pRegions, object.regionCount, settings, "const VkImageCopy2*", "pRegions", "const VkImageCopy2", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkImageCopy2); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBufferImageCopy2(const VkBufferImageCopy2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bufferOffset, settings, "VkDeviceSize", "bufferOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bufferRowLength, settings, "uint32_t", "bufferRowLength", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bufferImageHeight, settings, "uint32_t", "bufferImageHeight", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageSubresourceLayers(object.imageSubresource, settings, "VkImageSubresourceLayers", "imageSubresource", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkOffset3D(object.imageOffset, settings, "VkOffset3D", "imageOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent3D(object.imageExtent, settings, "VkExtent3D", "imageExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCopyBufferToImageInfo2(const VkCopyBufferToImageInfo2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBuffer(object.srcBuffer, settings, "VkBuffer", "srcBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImage(object.dstImage, settings, "VkImage", "dstImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(object.dstImageLayout, settings, "VkImageLayout", "dstImageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.regionCount, settings, "uint32_t", "regionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pRegions, object.regionCount, settings, "const VkBufferImageCopy2*", "pRegions", "const VkBufferImageCopy2", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkBufferImageCopy2); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCopyImageToBufferInfo2(const VkCopyImageToBufferInfo2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImage(object.srcImage, settings, "VkImage", "srcImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(object.srcImageLayout, settings, "VkImageLayout", "srcImageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBuffer(object.dstBuffer, settings, "VkBuffer", "dstBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.regionCount, settings, "uint32_t", "regionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pRegions, object.regionCount, settings, "const VkBufferImageCopy2*", "pRegions", "const VkBufferImageCopy2", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkBufferImageCopy2); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(const VkPhysicalDeviceTextureCompressionASTCHDRFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.textureCompressionASTC_HDR, settings, "VkBool32", "textureCompressionASTC_HDR", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkFormatProperties3(const VkFormatProperties3& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormatFeatureFlags2(object.linearTilingFeatures, settings, "VkFormatFeatureFlags2", "linearTilingFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormatFeatureFlags2(object.optimalTilingFeatures, settings, "VkFormatFeatureFlags2", "optimalTilingFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormatFeatureFlags2(object.bufferFeatures, settings, "VkFormatFeatureFlags2", "bufferFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceMaintenance4Features(const VkPhysicalDeviceMaintenance4Features& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maintenance4, settings, "VkBool32", "maintenance4", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceMaintenance4Properties(const VkPhysicalDeviceMaintenance4Properties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxBufferSize, settings, "VkDeviceSize", "maxBufferSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDeviceBufferMemoryRequirements(const VkDeviceBufferMemoryRequirements& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pCreateInfo, settings, "const VkBufferCreateInfo*", "pCreateInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkBufferCreateInfo); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDeviceImageMemoryRequirements(const VkDeviceImageMemoryRequirements& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pCreateInfo, settings, "const VkImageCreateInfo*", "pCreateInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkImageCreateInfo); + dump_separate_members(settings); + dump_VkImageAspectFlagBits(object.planeAspect, settings, "VkImageAspectFlagBits", "planeAspect", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineCreationFeedback(const VkPipelineCreationFeedback& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkPipelineCreationFeedbackFlags(object.flags, settings, "VkPipelineCreationFeedbackFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.duration, settings, "uint64_t", "duration", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineCreationFeedbackCreateInfo(const VkPipelineCreationFeedbackCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pPipelineCreationFeedback, settings, "VkPipelineCreationFeedback*", "pPipelineCreationFeedback", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineCreationFeedback); + dump_separate_members(settings); + dump_type(object.pipelineStageCreationFeedbackCount, settings, "uint32_t", "pipelineStageCreationFeedbackCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pPipelineStageCreationFeedbacks, object.pipelineStageCreationFeedbackCount, settings, "VkPipelineCreationFeedback*", "pPipelineStageCreationFeedbacks", "VkPipelineCreationFeedback", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineCreationFeedback); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderTerminateInvocationFeatures(const VkPhysicalDeviceShaderTerminateInvocationFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderTerminateInvocation, settings, "VkBool32", "shaderTerminateInvocation", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderDemoteToHelperInvocation, settings, "VkBool32", "shaderDemoteToHelperInvocation", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDevicePipelineCreationCacheControlFeatures(const VkPhysicalDevicePipelineCreationCacheControlFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pipelineCreationCacheControl, settings, "VkBool32", "pipelineCreationCacheControl", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderZeroInitializeWorkgroupMemory, settings, "VkBool32", "shaderZeroInitializeWorkgroupMemory", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceImageRobustnessFeatures(const VkPhysicalDeviceImageRobustnessFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.robustImageAccess, settings, "VkBool32", "robustImageAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceSubgroupSizeControlFeatures(const VkPhysicalDeviceSubgroupSizeControlFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.subgroupSizeControl, settings, "VkBool32", "subgroupSizeControl", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.computeFullSubgroups, settings, "VkBool32", "computeFullSubgroups", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceSubgroupSizeControlProperties(const VkPhysicalDeviceSubgroupSizeControlProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minSubgroupSize, settings, "uint32_t", "minSubgroupSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxSubgroupSize, settings, "uint32_t", "maxSubgroupSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxComputeWorkgroupSubgroups, settings, "uint32_t", "maxComputeWorkgroupSubgroups", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkShaderStageFlags(object.requiredSubgroupSizeStages, settings, "VkShaderStageFlags", "requiredSubgroupSizeStages", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.requiredSubgroupSize, settings, "uint32_t", "requiredSubgroupSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceInlineUniformBlockFeatures(const VkPhysicalDeviceInlineUniformBlockFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.inlineUniformBlock, settings, "VkBool32", "inlineUniformBlock", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorBindingInlineUniformBlockUpdateAfterBind, settings, "VkBool32", "descriptorBindingInlineUniformBlockUpdateAfterBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceInlineUniformBlockProperties(const VkPhysicalDeviceInlineUniformBlockProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxInlineUniformBlockSize, settings, "uint32_t", "maxInlineUniformBlockSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPerStageDescriptorInlineUniformBlocks, settings, "uint32_t", "maxPerStageDescriptorInlineUniformBlocks", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDescriptorSetInlineUniformBlocks, settings, "uint32_t", "maxDescriptorSetInlineUniformBlocks", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDescriptorSetUpdateAfterBindInlineUniformBlocks, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindInlineUniformBlocks", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkWriteDescriptorSetInlineUniformBlock(const VkWriteDescriptorSetInlineUniformBlock& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dataSize, settings, "uint32_t", "dataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pData, settings, "const void*", "pData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDescriptorPoolInlineUniformBlockCreateInfo(const VkDescriptorPoolInlineUniformBlockCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxInlineUniformBlockBindings, settings, "uint32_t", "maxInlineUniformBlockBindings", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderIntegerDotProductFeatures(const VkPhysicalDeviceShaderIntegerDotProductFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderIntegerDotProduct, settings, "VkBool32", "shaderIntegerDotProduct", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderIntegerDotProductProperties(const VkPhysicalDeviceShaderIntegerDotProductProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProduct8BitUnsignedAccelerated, settings, "VkBool32", "integerDotProduct8BitUnsignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProduct8BitSignedAccelerated, settings, "VkBool32", "integerDotProduct8BitSignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProduct8BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProduct8BitMixedSignednessAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProduct4x8BitPackedUnsignedAccelerated, settings, "VkBool32", "integerDotProduct4x8BitPackedUnsignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProduct4x8BitPackedSignedAccelerated, settings, "VkBool32", "integerDotProduct4x8BitPackedSignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProduct4x8BitPackedMixedSignednessAccelerated, settings, "VkBool32", "integerDotProduct4x8BitPackedMixedSignednessAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProduct16BitUnsignedAccelerated, settings, "VkBool32", "integerDotProduct16BitUnsignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProduct16BitSignedAccelerated, settings, "VkBool32", "integerDotProduct16BitSignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProduct16BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProduct16BitMixedSignednessAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProduct32BitUnsignedAccelerated, settings, "VkBool32", "integerDotProduct32BitUnsignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProduct32BitSignedAccelerated, settings, "VkBool32", "integerDotProduct32BitSignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProduct32BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProduct32BitMixedSignednessAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProduct64BitUnsignedAccelerated, settings, "VkBool32", "integerDotProduct64BitUnsignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProduct64BitSignedAccelerated, settings, "VkBool32", "integerDotProduct64BitSignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProduct64BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProduct64BitMixedSignednessAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating8BitUnsignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProductAccumulatingSaturating8BitSignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating8BitSignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating16BitUnsignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProductAccumulatingSaturating16BitSignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating16BitSignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating32BitUnsignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProductAccumulatingSaturating32BitSignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating32BitSignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating64BitUnsignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProductAccumulatingSaturating64BitSignedAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating64BitSignedAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated, settings, "VkBool32", "integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceTexelBufferAlignmentProperties(const VkPhysicalDeviceTexelBufferAlignmentProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.storageTexelBufferOffsetAlignmentBytes, settings, "VkDeviceSize", "storageTexelBufferOffsetAlignmentBytes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.storageTexelBufferOffsetSingleTexelAlignment, settings, "VkBool32", "storageTexelBufferOffsetSingleTexelAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.uniformTexelBufferOffsetAlignmentBytes, settings, "VkDeviceSize", "uniformTexelBufferOffsetAlignmentBytes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.uniformTexelBufferOffsetSingleTexelAlignment, settings, "VkBool32", "uniformTexelBufferOffsetSingleTexelAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImageBlit2(const VkImageBlit2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageSubresourceLayers(object.srcSubresource, settings, "VkImageSubresourceLayers", "srcSubresource", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.srcOffsets, 2, settings, "VkOffset3D[2]", "srcOffsets", "VkOffset3D", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkOffset3D); + dump_separate_members(settings); + dump_VkImageSubresourceLayers(object.dstSubresource, settings, "VkImageSubresourceLayers", "dstSubresource", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.dstOffsets, 2, settings, "VkOffset3D[2]", "dstOffsets", "VkOffset3D", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkOffset3D); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBlitImageInfo2(const VkBlitImageInfo2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImage(object.srcImage, settings, "VkImage", "srcImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(object.srcImageLayout, settings, "VkImageLayout", "srcImageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImage(object.dstImage, settings, "VkImage", "dstImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(object.dstImageLayout, settings, "VkImageLayout", "dstImageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.regionCount, settings, "uint32_t", "regionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pRegions, object.regionCount, settings, "const VkImageBlit2*", "pRegions", "const VkImageBlit2", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkImageBlit2); + dump_separate_members(settings); + dump_VkFilter(object.filter, settings, "VkFilter", "filter", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImageResolve2(const VkImageResolve2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageSubresourceLayers(object.srcSubresource, settings, "VkImageSubresourceLayers", "srcSubresource", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkOffset3D(object.srcOffset, settings, "VkOffset3D", "srcOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageSubresourceLayers(object.dstSubresource, settings, "VkImageSubresourceLayers", "dstSubresource", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkOffset3D(object.dstOffset, settings, "VkOffset3D", "dstOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent3D(object.extent, settings, "VkExtent3D", "extent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkResolveImageInfo2(const VkResolveImageInfo2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImage(object.srcImage, settings, "VkImage", "srcImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(object.srcImageLayout, settings, "VkImageLayout", "srcImageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImage(object.dstImage, settings, "VkImage", "dstImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(object.dstImageLayout, settings, "VkImageLayout", "dstImageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.regionCount, settings, "uint32_t", "regionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pRegions, object.regionCount, settings, "const VkImageResolve2*", "pRegions", "const VkImageResolve2", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkImageResolve2); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkRenderingAttachmentInfo(const VkRenderingAttachmentInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageView(object.imageView, settings, "VkImageView", "imageView", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(object.imageLayout, settings, "VkImageLayout", "imageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkResolveModeFlagBits(object.resolveMode, settings, "VkResolveModeFlagBits", "resolveMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageView(object.resolveImageView, settings, "VkImageView", "resolveImageView", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(object.resolveImageLayout, settings, "VkImageLayout", "resolveImageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAttachmentLoadOp(object.loadOp, settings, "VkAttachmentLoadOp", "loadOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAttachmentStoreOp(object.storeOp, settings, "VkAttachmentStoreOp", "storeOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkClearValue(object.clearValue, settings, "VkClearValue", "clearValue", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkRenderingInfo(const VkRenderingInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkRenderingFlags(object.flags, settings, "VkRenderingFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkRect2D(object.renderArea, settings, "VkRect2D", "renderArea", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.layerCount, settings, "uint32_t", "layerCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.viewMask, settings, "uint32_t", "viewMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.colorAttachmentCount, settings, "uint32_t", "colorAttachmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pColorAttachments, object.colorAttachmentCount, settings, "const VkRenderingAttachmentInfo*", "pColorAttachments", "const VkRenderingAttachmentInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkRenderingAttachmentInfo); + dump_separate_members(settings); + dump_pointer(object.pDepthAttachment, settings, "const VkRenderingAttachmentInfo*", "pDepthAttachment", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkRenderingAttachmentInfo); + dump_separate_members(settings); + dump_pointer(object.pStencilAttachment, settings, "const VkRenderingAttachmentInfo*", "pStencilAttachment", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkRenderingAttachmentInfo); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineRenderingCreateInfo(const VkPipelineRenderingCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.viewMask, settings, "uint32_t", "viewMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + if (!ApiDumpInstance::current().getIsGPLPreRasterOrFragmentShader()) { + dump_type(object.colorAttachmentCount, settings, "uint32_t", "colorAttachmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + } else { + if constexpr (Format == ApiDumpFormat::Text || Format == ApiDumpFormat::Html) { + dump_special("UNUSED", settings, "uint32_t", "colorAttachmentCount", indents + 1); + } else if constexpr (Format == ApiDumpFormat::Json) { + dump_json_UNUSED(settings, "uint32_t", "colorAttachmentCount", indents + 2); + } + } + dump_separate_members(settings); + if (!ApiDumpInstance::current().getIsGPLPreRasterOrFragmentShader()) { + dump_pointer_array(object.pColorAttachmentFormats, object.colorAttachmentCount, settings, "const VkFormat*", "pColorAttachmentFormats", "const VkFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkFormat); + } else { + if constexpr (Format == ApiDumpFormat::Text || Format == ApiDumpFormat::Html) { + dump_special("UNUSED", settings, "const VkFormat*", "pColorAttachmentFormats", indents + 1); + } else if constexpr (Format == ApiDumpFormat::Json) { + dump_json_UNUSED(settings, "const VkFormat*", "pColorAttachmentFormats", indents + 2); + } + } + dump_separate_members(settings); + if (!ApiDumpInstance::current().getIsGPLPreRasterOrFragmentShader()) { + dump_VkFormat(object.depthAttachmentFormat, settings, "VkFormat", "depthAttachmentFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + } else { + if constexpr (Format == ApiDumpFormat::Text || Format == ApiDumpFormat::Html) { + dump_special("UNUSED", settings, "VkFormat", "depthAttachmentFormat", indents + 1); + } else if constexpr (Format == ApiDumpFormat::Json) { + dump_json_UNUSED(settings, "VkFormat", "depthAttachmentFormat", indents + 2); + } + } + dump_separate_members(settings); + if (!ApiDumpInstance::current().getIsGPLPreRasterOrFragmentShader()) { + dump_VkFormat(object.stencilAttachmentFormat, settings, "VkFormat", "stencilAttachmentFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + } else { + if constexpr (Format == ApiDumpFormat::Text || Format == ApiDumpFormat::Html) { + dump_special("UNUSED", settings, "VkFormat", "stencilAttachmentFormat", indents + 1); + } else if constexpr (Format == ApiDumpFormat::Json) { + dump_json_UNUSED(settings, "VkFormat", "stencilAttachmentFormat", indents + 2); + } + } + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceDynamicRenderingFeatures(const VkPhysicalDeviceDynamicRenderingFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dynamicRendering, settings, "VkBool32", "dynamicRendering", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCommandBufferInheritanceRenderingInfo(const VkCommandBufferInheritanceRenderingInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkRenderingFlags(object.flags, settings, "VkRenderingFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.viewMask, settings, "uint32_t", "viewMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.colorAttachmentCount, settings, "uint32_t", "colorAttachmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pColorAttachmentFormats, object.colorAttachmentCount, settings, "const VkFormat*", "pColorAttachmentFormats", "const VkFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkFormat); + dump_separate_members(settings); + dump_VkFormat(object.depthAttachmentFormat, settings, "VkFormat", "depthAttachmentFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormat(object.stencilAttachmentFormat, settings, "VkFormat", "stencilAttachmentFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSampleCountFlagBits(object.rasterizationSamples, settings, "VkSampleCountFlagBits", "rasterizationSamples", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceVulkan14Features(const VkPhysicalDeviceVulkan14Features& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.globalPriorityQuery, settings, "VkBool32", "globalPriorityQuery", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderSubgroupRotate, settings, "VkBool32", "shaderSubgroupRotate", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderSubgroupRotateClustered, settings, "VkBool32", "shaderSubgroupRotateClustered", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderFloatControls2, settings, "VkBool32", "shaderFloatControls2", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderExpectAssume, settings, "VkBool32", "shaderExpectAssume", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.rectangularLines, settings, "VkBool32", "rectangularLines", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bresenhamLines, settings, "VkBool32", "bresenhamLines", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.smoothLines, settings, "VkBool32", "smoothLines", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.stippledRectangularLines, settings, "VkBool32", "stippledRectangularLines", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.stippledBresenhamLines, settings, "VkBool32", "stippledBresenhamLines", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.stippledSmoothLines, settings, "VkBool32", "stippledSmoothLines", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vertexAttributeInstanceRateDivisor, settings, "VkBool32", "vertexAttributeInstanceRateDivisor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vertexAttributeInstanceRateZeroDivisor, settings, "VkBool32", "vertexAttributeInstanceRateZeroDivisor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.indexTypeUint8, settings, "VkBool32", "indexTypeUint8", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dynamicRenderingLocalRead, settings, "VkBool32", "dynamicRenderingLocalRead", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maintenance5, settings, "VkBool32", "maintenance5", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maintenance6, settings, "VkBool32", "maintenance6", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pipelineProtectedAccess, settings, "VkBool32", "pipelineProtectedAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pipelineRobustness, settings, "VkBool32", "pipelineRobustness", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.hostImageCopy, settings, "VkBool32", "hostImageCopy", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pushDescriptor, settings, "VkBool32", "pushDescriptor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceVulkan14Properties(const VkPhysicalDeviceVulkan14Properties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.lineSubPixelPrecisionBits, settings, "uint32_t", "lineSubPixelPrecisionBits", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxVertexAttribDivisor, settings, "uint32_t", "maxVertexAttribDivisor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.supportsNonZeroFirstInstance, settings, "VkBool32", "supportsNonZeroFirstInstance", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPushDescriptors, settings, "uint32_t", "maxPushDescriptors", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dynamicRenderingLocalReadDepthStencilAttachments, settings, "VkBool32", "dynamicRenderingLocalReadDepthStencilAttachments", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dynamicRenderingLocalReadMultisampledAttachments, settings, "VkBool32", "dynamicRenderingLocalReadMultisampledAttachments", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.earlyFragmentMultisampleCoverageAfterSampleCounting, settings, "VkBool32", "earlyFragmentMultisampleCoverageAfterSampleCounting", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.earlyFragmentSampleMaskTestBeforeSampleCounting, settings, "VkBool32", "earlyFragmentSampleMaskTestBeforeSampleCounting", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.depthStencilSwizzleOneSupport, settings, "VkBool32", "depthStencilSwizzleOneSupport", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.polygonModePointSize, settings, "VkBool32", "polygonModePointSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.nonStrictSinglePixelWideLinesUseParallelogram, settings, "VkBool32", "nonStrictSinglePixelWideLinesUseParallelogram", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.nonStrictWideLinesUseParallelogram, settings, "VkBool32", "nonStrictWideLinesUseParallelogram", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.blockTexelViewCompatibleMultipleLayers, settings, "VkBool32", "blockTexelViewCompatibleMultipleLayers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxCombinedImageSamplerDescriptorCount, settings, "uint32_t", "maxCombinedImageSamplerDescriptorCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.fragmentShadingRateClampCombinerInputs, settings, "VkBool32", "fragmentShadingRateClampCombinerInputs", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineRobustnessBufferBehavior(object.defaultRobustnessStorageBuffers, settings, "VkPipelineRobustnessBufferBehavior", "defaultRobustnessStorageBuffers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineRobustnessBufferBehavior(object.defaultRobustnessUniformBuffers, settings, "VkPipelineRobustnessBufferBehavior", "defaultRobustnessUniformBuffers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineRobustnessBufferBehavior(object.defaultRobustnessVertexInputs, settings, "VkPipelineRobustnessBufferBehavior", "defaultRobustnessVertexInputs", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineRobustnessImageBehavior(object.defaultRobustnessImages, settings, "VkPipelineRobustnessImageBehavior", "defaultRobustnessImages", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.copySrcLayoutCount, settings, "uint32_t", "copySrcLayoutCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pCopySrcLayouts, object.copySrcLayoutCount, settings, "VkImageLayout*", "pCopySrcLayouts", "VkImageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkImageLayout); + dump_separate_members(settings); + dump_type(object.copyDstLayoutCount, settings, "uint32_t", "copyDstLayoutCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pCopyDstLayouts, object.copyDstLayoutCount, settings, "VkImageLayout*", "pCopyDstLayouts", "VkImageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkImageLayout); + dump_separate_members(settings); + dump_single_array(object.optimalTilingLayoutUUID, VK_UUID_SIZE, settings, "uint8_t[VK_UUID_SIZE]", "optimalTilingLayoutUUID", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.identicalMemoryTypeRequirements, settings, "VkBool32", "identicalMemoryTypeRequirements", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDeviceQueueGlobalPriorityCreateInfo(const VkDeviceQueueGlobalPriorityCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkQueueGlobalPriority(object.globalPriority, settings, "VkQueueGlobalPriority", "globalPriority", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceGlobalPriorityQueryFeatures(const VkPhysicalDeviceGlobalPriorityQueryFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.globalPriorityQuery, settings, "VkBool32", "globalPriorityQuery", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkQueueFamilyGlobalPriorityProperties(const VkQueueFamilyGlobalPriorityProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.priorityCount, settings, "uint32_t", "priorityCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.priorities, std::min(object.priorityCount, VK_MAX_GLOBAL_PRIORITY_SIZE), settings, "VkQueueGlobalPriority[VK_MAX_GLOBAL_PRIORITY_SIZE]", "priorities", "VkQueueGlobalPriority", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkQueueGlobalPriority); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceIndexTypeUint8Features(const VkPhysicalDeviceIndexTypeUint8Features& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.indexTypeUint8, settings, "VkBool32", "indexTypeUint8", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMemoryMapInfo(const VkMemoryMapInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkMemoryMapFlags(object.flags, settings, "VkMemoryMapFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceMemory(object.memory, settings, "VkDeviceMemory", "memory", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.offset, settings, "VkDeviceSize", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMemoryUnmapInfo(const VkMemoryUnmapInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkMemoryUnmapFlags(object.flags, settings, "VkMemoryUnmapFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceMemory(object.memory, settings, "VkDeviceMemory", "memory", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceMaintenance5Features(const VkPhysicalDeviceMaintenance5Features& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maintenance5, settings, "VkBool32", "maintenance5", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceMaintenance5Properties(const VkPhysicalDeviceMaintenance5Properties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.earlyFragmentMultisampleCoverageAfterSampleCounting, settings, "VkBool32", "earlyFragmentMultisampleCoverageAfterSampleCounting", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.earlyFragmentSampleMaskTestBeforeSampleCounting, settings, "VkBool32", "earlyFragmentSampleMaskTestBeforeSampleCounting", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.depthStencilSwizzleOneSupport, settings, "VkBool32", "depthStencilSwizzleOneSupport", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.polygonModePointSize, settings, "VkBool32", "polygonModePointSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.nonStrictSinglePixelWideLinesUseParallelogram, settings, "VkBool32", "nonStrictSinglePixelWideLinesUseParallelogram", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.nonStrictWideLinesUseParallelogram, settings, "VkBool32", "nonStrictWideLinesUseParallelogram", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImageSubresource2(const VkImageSubresource2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageSubresource(object.imageSubresource, settings, "VkImageSubresource", "imageSubresource", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDeviceImageSubresourceInfo(const VkDeviceImageSubresourceInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pCreateInfo, settings, "const VkImageCreateInfo*", "pCreateInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkImageCreateInfo); + dump_separate_members(settings); + dump_pointer(object.pSubresource, settings, "const VkImageSubresource2*", "pSubresource", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkImageSubresource2); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSubresourceLayout2(const VkSubresourceLayout2& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSubresourceLayout(object.subresourceLayout, settings, "VkSubresourceLayout", "subresourceLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBufferUsageFlags2CreateInfo(const VkBufferUsageFlags2CreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBufferUsageFlags2(object.usage, settings, "VkBufferUsageFlags2", "usage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceMaintenance6Features(const VkPhysicalDeviceMaintenance6Features& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maintenance6, settings, "VkBool32", "maintenance6", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceMaintenance6Properties(const VkPhysicalDeviceMaintenance6Properties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.blockTexelViewCompatibleMultipleLayers, settings, "VkBool32", "blockTexelViewCompatibleMultipleLayers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxCombinedImageSamplerDescriptorCount, settings, "uint32_t", "maxCombinedImageSamplerDescriptorCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.fragmentShadingRateClampCombinerInputs, settings, "VkBool32", "fragmentShadingRateClampCombinerInputs", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBindMemoryStatus(const VkBindMemoryStatus& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pResult, settings, "VkResult*", "pResult", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkResult); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceHostImageCopyFeatures(const VkPhysicalDeviceHostImageCopyFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.hostImageCopy, settings, "VkBool32", "hostImageCopy", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceHostImageCopyProperties(const VkPhysicalDeviceHostImageCopyProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.copySrcLayoutCount, settings, "uint32_t", "copySrcLayoutCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pCopySrcLayouts, object.copySrcLayoutCount, settings, "VkImageLayout*", "pCopySrcLayouts", "VkImageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkImageLayout); + dump_separate_members(settings); + dump_type(object.copyDstLayoutCount, settings, "uint32_t", "copyDstLayoutCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pCopyDstLayouts, object.copyDstLayoutCount, settings, "VkImageLayout*", "pCopyDstLayouts", "VkImageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkImageLayout); + dump_separate_members(settings); + dump_single_array(object.optimalTilingLayoutUUID, VK_UUID_SIZE, settings, "uint8_t[VK_UUID_SIZE]", "optimalTilingLayoutUUID", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.identicalMemoryTypeRequirements, settings, "VkBool32", "identicalMemoryTypeRequirements", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMemoryToImageCopy(const VkMemoryToImageCopy& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pHostPointer, settings, "const void*", "pHostPointer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.memoryRowLength, settings, "uint32_t", "memoryRowLength", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.memoryImageHeight, settings, "uint32_t", "memoryImageHeight", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageSubresourceLayers(object.imageSubresource, settings, "VkImageSubresourceLayers", "imageSubresource", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkOffset3D(object.imageOffset, settings, "VkOffset3D", "imageOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent3D(object.imageExtent, settings, "VkExtent3D", "imageExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImageToMemoryCopy(const VkImageToMemoryCopy& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pHostPointer, settings, "void*", "pHostPointer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.memoryRowLength, settings, "uint32_t", "memoryRowLength", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.memoryImageHeight, settings, "uint32_t", "memoryImageHeight", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageSubresourceLayers(object.imageSubresource, settings, "VkImageSubresourceLayers", "imageSubresource", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkOffset3D(object.imageOffset, settings, "VkOffset3D", "imageOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent3D(object.imageExtent, settings, "VkExtent3D", "imageExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCopyMemoryToImageInfo(const VkCopyMemoryToImageInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkHostImageCopyFlags(object.flags, settings, "VkHostImageCopyFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImage(object.dstImage, settings, "VkImage", "dstImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(object.dstImageLayout, settings, "VkImageLayout", "dstImageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.regionCount, settings, "uint32_t", "regionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pRegions, object.regionCount, settings, "const VkMemoryToImageCopy*", "pRegions", "const VkMemoryToImageCopy", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkMemoryToImageCopy); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCopyImageToMemoryInfo(const VkCopyImageToMemoryInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkHostImageCopyFlags(object.flags, settings, "VkHostImageCopyFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImage(object.srcImage, settings, "VkImage", "srcImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(object.srcImageLayout, settings, "VkImageLayout", "srcImageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.regionCount, settings, "uint32_t", "regionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pRegions, object.regionCount, settings, "const VkImageToMemoryCopy*", "pRegions", "const VkImageToMemoryCopy", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkImageToMemoryCopy); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCopyImageToImageInfo(const VkCopyImageToImageInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkHostImageCopyFlags(object.flags, settings, "VkHostImageCopyFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImage(object.srcImage, settings, "VkImage", "srcImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(object.srcImageLayout, settings, "VkImageLayout", "srcImageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImage(object.dstImage, settings, "VkImage", "dstImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(object.dstImageLayout, settings, "VkImageLayout", "dstImageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.regionCount, settings, "uint32_t", "regionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pRegions, object.regionCount, settings, "const VkImageCopy2*", "pRegions", "const VkImageCopy2", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkImageCopy2); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkHostImageLayoutTransitionInfo(const VkHostImageLayoutTransitionInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImage(object.image, settings, "VkImage", "image", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(object.oldLayout, settings, "VkImageLayout", "oldLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(object.newLayout, settings, "VkImageLayout", "newLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageSubresourceRange(object.subresourceRange, settings, "VkImageSubresourceRange", "subresourceRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSubresourceHostMemcpySize(const VkSubresourceHostMemcpySize& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkHostImageCopyDevicePerformanceQuery(const VkHostImageCopyDevicePerformanceQuery& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.optimalDeviceAccess, settings, "VkBool32", "optimalDeviceAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.identicalMemoryLayout, settings, "VkBool32", "identicalMemoryLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderSubgroupRotateFeatures(const VkPhysicalDeviceShaderSubgroupRotateFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderSubgroupRotate, settings, "VkBool32", "shaderSubgroupRotate", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderSubgroupRotateClustered, settings, "VkBool32", "shaderSubgroupRotateClustered", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderFloatControls2Features(const VkPhysicalDeviceShaderFloatControls2Features& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderFloatControls2, settings, "VkBool32", "shaderFloatControls2", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderExpectAssumeFeatures(const VkPhysicalDeviceShaderExpectAssumeFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderExpectAssume, settings, "VkBool32", "shaderExpectAssume", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineCreateFlags2CreateInfo(const VkPipelineCreateFlags2CreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineCreateFlags2(object.flags, settings, "VkPipelineCreateFlags2", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDevicePushDescriptorProperties(const VkPhysicalDevicePushDescriptorProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPushDescriptors, settings, "uint32_t", "maxPushDescriptors", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBindDescriptorSetsInfo(const VkBindDescriptorSetsInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkShaderStageFlags(object.stageFlags, settings, "VkShaderStageFlags", "stageFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineLayout(object.layout, settings, "VkPipelineLayout", "layout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.firstSet, settings, "uint32_t", "firstSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorSetCount, settings, "uint32_t", "descriptorSetCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pDescriptorSets, object.descriptorSetCount, settings, "const VkDescriptorSet*", "pDescriptorSets", "const VkDescriptorSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorSet); + dump_separate_members(settings); + dump_type(object.dynamicOffsetCount, settings, "uint32_t", "dynamicOffsetCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pDynamicOffsets, object.dynamicOffsetCount, settings, "const uint32_t*", "pDynamicOffsets", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPushConstantsInfo(const VkPushConstantsInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineLayout(object.layout, settings, "VkPipelineLayout", "layout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkShaderStageFlags(object.stageFlags, settings, "VkShaderStageFlags", "stageFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.offset, settings, "uint32_t", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.size, settings, "uint32_t", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pValues, settings, "const void*", "pValues", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPushDescriptorSetInfo(const VkPushDescriptorSetInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkShaderStageFlags(object.stageFlags, settings, "VkShaderStageFlags", "stageFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineLayout(object.layout, settings, "VkPipelineLayout", "layout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.set, settings, "uint32_t", "set", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorWriteCount, settings, "uint32_t", "descriptorWriteCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pDescriptorWrites, object.descriptorWriteCount, settings, "const VkWriteDescriptorSet*", "pDescriptorWrites", "const VkWriteDescriptorSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkWriteDescriptorSet); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPushDescriptorSetWithTemplateInfo(const VkPushDescriptorSetWithTemplateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDescriptorUpdateTemplate(object.descriptorUpdateTemplate, settings, "VkDescriptorUpdateTemplate", "descriptorUpdateTemplate", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineLayout(object.layout, settings, "VkPipelineLayout", "layout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.set, settings, "uint32_t", "set", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pData, settings, "const void*", "pData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDevicePipelineProtectedAccessFeatures(const VkPhysicalDevicePipelineProtectedAccessFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pipelineProtectedAccess, settings, "VkBool32", "pipelineProtectedAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDevicePipelineRobustnessFeatures(const VkPhysicalDevicePipelineRobustnessFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pipelineRobustness, settings, "VkBool32", "pipelineRobustness", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDevicePipelineRobustnessProperties(const VkPhysicalDevicePipelineRobustnessProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineRobustnessBufferBehavior(object.defaultRobustnessStorageBuffers, settings, "VkPipelineRobustnessBufferBehavior", "defaultRobustnessStorageBuffers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineRobustnessBufferBehavior(object.defaultRobustnessUniformBuffers, settings, "VkPipelineRobustnessBufferBehavior", "defaultRobustnessUniformBuffers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineRobustnessBufferBehavior(object.defaultRobustnessVertexInputs, settings, "VkPipelineRobustnessBufferBehavior", "defaultRobustnessVertexInputs", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineRobustnessImageBehavior(object.defaultRobustnessImages, settings, "VkPipelineRobustnessImageBehavior", "defaultRobustnessImages", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineRobustnessCreateInfo(const VkPipelineRobustnessCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineRobustnessBufferBehavior(object.storageBuffers, settings, "VkPipelineRobustnessBufferBehavior", "storageBuffers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineRobustnessBufferBehavior(object.uniformBuffers, settings, "VkPipelineRobustnessBufferBehavior", "uniformBuffers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineRobustnessBufferBehavior(object.vertexInputs, settings, "VkPipelineRobustnessBufferBehavior", "vertexInputs", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineRobustnessImageBehavior(object.images, settings, "VkPipelineRobustnessImageBehavior", "images", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceLineRasterizationFeatures(const VkPhysicalDeviceLineRasterizationFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.rectangularLines, settings, "VkBool32", "rectangularLines", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bresenhamLines, settings, "VkBool32", "bresenhamLines", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.smoothLines, settings, "VkBool32", "smoothLines", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.stippledRectangularLines, settings, "VkBool32", "stippledRectangularLines", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.stippledBresenhamLines, settings, "VkBool32", "stippledBresenhamLines", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.stippledSmoothLines, settings, "VkBool32", "stippledSmoothLines", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceLineRasterizationProperties(const VkPhysicalDeviceLineRasterizationProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.lineSubPixelPrecisionBits, settings, "uint32_t", "lineSubPixelPrecisionBits", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineRasterizationLineStateCreateInfo(const VkPipelineRasterizationLineStateCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkLineRasterizationMode(object.lineRasterizationMode, settings, "VkLineRasterizationMode", "lineRasterizationMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.stippledLineEnable, settings, "VkBool32", "stippledLineEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.lineStippleFactor, settings, "uint32_t", "lineStippleFactor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.lineStipplePattern, settings, "uint16_t", "lineStipplePattern", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceVertexAttributeDivisorProperties(const VkPhysicalDeviceVertexAttributeDivisorProperties& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxVertexAttribDivisor, settings, "uint32_t", "maxVertexAttribDivisor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.supportsNonZeroFirstInstance, settings, "VkBool32", "supportsNonZeroFirstInstance", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVertexInputBindingDivisorDescription(const VkVertexInputBindingDivisorDescription& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.binding, settings, "uint32_t", "binding", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.divisor, settings, "uint32_t", "divisor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineVertexInputDivisorStateCreateInfo(const VkPipelineVertexInputDivisorStateCreateInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vertexBindingDivisorCount, settings, "uint32_t", "vertexBindingDivisorCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pVertexBindingDivisors, object.vertexBindingDivisorCount, settings, "const VkVertexInputBindingDivisorDescription*", "pVertexBindingDivisors", "const VkVertexInputBindingDivisorDescription", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkVertexInputBindingDivisorDescription); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceVertexAttributeDivisorFeatures(const VkPhysicalDeviceVertexAttributeDivisorFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vertexAttributeInstanceRateDivisor, settings, "VkBool32", "vertexAttributeInstanceRateDivisor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vertexAttributeInstanceRateZeroDivisor, settings, "VkBool32", "vertexAttributeInstanceRateZeroDivisor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkRenderingAreaInfo(const VkRenderingAreaInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.viewMask, settings, "uint32_t", "viewMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.colorAttachmentCount, settings, "uint32_t", "colorAttachmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pColorAttachmentFormats, object.colorAttachmentCount, settings, "const VkFormat*", "pColorAttachmentFormats", "const VkFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkFormat); + dump_separate_members(settings); + dump_VkFormat(object.depthAttachmentFormat, settings, "VkFormat", "depthAttachmentFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormat(object.stencilAttachmentFormat, settings, "VkFormat", "stencilAttachmentFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceDynamicRenderingLocalReadFeatures(const VkPhysicalDeviceDynamicRenderingLocalReadFeatures& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dynamicRenderingLocalRead, settings, "VkBool32", "dynamicRenderingLocalRead", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkRenderingAttachmentLocationInfo(const VkRenderingAttachmentLocationInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.colorAttachmentCount, settings, "uint32_t", "colorAttachmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pColorAttachmentLocations, object.colorAttachmentCount, settings, "const uint32_t*", "pColorAttachmentLocations", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkRenderingInputAttachmentIndexInfo(const VkRenderingInputAttachmentIndexInfo& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.colorAttachmentCount, settings, "uint32_t", "colorAttachmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pColorAttachmentInputIndices, object.colorAttachmentCount, settings, "const uint32_t*", "pColorAttachmentInputIndices", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_pointer(object.pDepthInputAttachmentIndex, settings, "const uint32_t*", "pDepthInputAttachmentIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_pointer(object.pStencilInputAttachmentIndex, settings, "const uint32_t*", "pStencilInputAttachmentIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSurfaceCapabilitiesKHR(const VkSurfaceCapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.minImageCount, settings, "uint32_t", "minImageCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxImageCount, settings, "uint32_t", "maxImageCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.currentExtent, settings, "VkExtent2D", "currentExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.minImageExtent, settings, "VkExtent2D", "minImageExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.maxImageExtent, settings, "VkExtent2D", "maxImageExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxImageArrayLayers, settings, "uint32_t", "maxImageArrayLayers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSurfaceTransformFlagsKHR(object.supportedTransforms, settings, "VkSurfaceTransformFlagsKHR", "supportedTransforms", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSurfaceTransformFlagBitsKHR(object.currentTransform, settings, "VkSurfaceTransformFlagBitsKHR", "currentTransform", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkCompositeAlphaFlagsKHR(object.supportedCompositeAlpha, settings, "VkCompositeAlphaFlagsKHR", "supportedCompositeAlpha", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageUsageFlags(object.supportedUsageFlags, settings, "VkImageUsageFlags", "supportedUsageFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSurfaceFormatKHR(const VkSurfaceFormatKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkFormat(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkColorSpaceKHR(object.colorSpace, settings, "VkColorSpaceKHR", "colorSpace", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSwapchainCreateInfoKHR(const VkSwapchainCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSwapchainCreateFlagsKHR(object.flags, settings, "VkSwapchainCreateFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSurfaceKHR(object.surface, settings, "VkSurfaceKHR", "surface", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minImageCount, settings, "uint32_t", "minImageCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormat(object.imageFormat, settings, "VkFormat", "imageFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkColorSpaceKHR(object.imageColorSpace, settings, "VkColorSpaceKHR", "imageColorSpace", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.imageExtent, settings, "VkExtent2D", "imageExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.imageArrayLayers, settings, "uint32_t", "imageArrayLayers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageUsageFlags(object.imageUsage, settings, "VkImageUsageFlags", "imageUsage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSharingMode(object.imageSharingMode, settings, "VkSharingMode", "imageSharingMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.queueFamilyIndexCount, settings, "uint32_t", "queueFamilyIndexCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + if (object.imageSharingMode == VK_SHARING_MODE_CONCURRENT) { + dump_pointer_array(object.pQueueFamilyIndices, object.queueFamilyIndexCount, settings, "const uint32_t*", "pQueueFamilyIndices", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + } else { + if constexpr (Format == ApiDumpFormat::Text || Format == ApiDumpFormat::Html) { + dump_special("UNUSED", settings, "const uint32_t*", "pQueueFamilyIndices", indents + 1); + } else if constexpr (Format == ApiDumpFormat::Json) { + dump_json_UNUSED(settings, "const uint32_t*", "pQueueFamilyIndices", indents + 2); + } + } + dump_separate_members(settings); + dump_VkSurfaceTransformFlagBitsKHR(object.preTransform, settings, "VkSurfaceTransformFlagBitsKHR", "preTransform", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkCompositeAlphaFlagBitsKHR(object.compositeAlpha, settings, "VkCompositeAlphaFlagBitsKHR", "compositeAlpha", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPresentModeKHR(object.presentMode, settings, "VkPresentModeKHR", "presentMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.clipped, settings, "VkBool32", "clipped", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSwapchainKHR(object.oldSwapchain, settings, "VkSwapchainKHR", "oldSwapchain", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPresentInfoKHR(const VkPresentInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.waitSemaphoreCount, settings, "uint32_t", "waitSemaphoreCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pWaitSemaphores, object.waitSemaphoreCount, settings, "const VkSemaphore*", "pWaitSemaphores", "const VkSemaphore", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSemaphore); + dump_separate_members(settings); + dump_type(object.swapchainCount, settings, "uint32_t", "swapchainCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pSwapchains, object.swapchainCount, settings, "const VkSwapchainKHR*", "pSwapchains", "const VkSwapchainKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSwapchainKHR); + dump_separate_members(settings); + dump_pointer_array(object.pImageIndices, object.swapchainCount, settings, "const uint32_t*", "pImageIndices", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(object.pResults, object.swapchainCount, settings, "VkResult*", "pResults", "VkResult", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkResult); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImageSwapchainCreateInfoKHR(const VkImageSwapchainCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSwapchainKHR(object.swapchain, settings, "VkSwapchainKHR", "swapchain", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBindImageMemorySwapchainInfoKHR(const VkBindImageMemorySwapchainInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSwapchainKHR(object.swapchain, settings, "VkSwapchainKHR", "swapchain", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.imageIndex, settings, "uint32_t", "imageIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAcquireNextImageInfoKHR(const VkAcquireNextImageInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSwapchainKHR(object.swapchain, settings, "VkSwapchainKHR", "swapchain", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.timeout, settings, "uint64_t", "timeout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSemaphore(object.semaphore, settings, "VkSemaphore", "semaphore", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFence(object.fence, settings, "VkFence", "fence", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.deviceMask, settings, "uint32_t", "deviceMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDeviceGroupPresentCapabilitiesKHR(const VkDeviceGroupPresentCapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.presentMask, VK_MAX_DEVICE_GROUP_SIZE, settings, "uint32_t[VK_MAX_DEVICE_GROUP_SIZE]", "presentMask", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_VkDeviceGroupPresentModeFlagsKHR(object.modes, settings, "VkDeviceGroupPresentModeFlagsKHR", "modes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDeviceGroupPresentInfoKHR(const VkDeviceGroupPresentInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.swapchainCount, settings, "uint32_t", "swapchainCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pDeviceMasks, object.swapchainCount, settings, "const uint32_t*", "pDeviceMasks", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_VkDeviceGroupPresentModeFlagBitsKHR(object.mode, settings, "VkDeviceGroupPresentModeFlagBitsKHR", "mode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDeviceGroupSwapchainCreateInfoKHR(const VkDeviceGroupSwapchainCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceGroupPresentModeFlagsKHR(object.modes, settings, "VkDeviceGroupPresentModeFlagsKHR", "modes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDisplayModeParametersKHR(const VkDisplayModeParametersKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkExtent2D(object.visibleRegion, settings, "VkExtent2D", "visibleRegion", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.refreshRate, settings, "uint32_t", "refreshRate", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDisplayModeCreateInfoKHR(const VkDisplayModeCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDisplayModeCreateFlagsKHR(object.flags, settings, "VkDisplayModeCreateFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDisplayModeParametersKHR(object.parameters, settings, "VkDisplayModeParametersKHR", "parameters", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDisplayModePropertiesKHR(const VkDisplayModePropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkDisplayModeKHR(object.displayMode, settings, "VkDisplayModeKHR", "displayMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDisplayModeParametersKHR(object.parameters, settings, "VkDisplayModeParametersKHR", "parameters", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDisplayPlaneCapabilitiesKHR(const VkDisplayPlaneCapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkDisplayPlaneAlphaFlagsKHR(object.supportedAlpha, settings, "VkDisplayPlaneAlphaFlagsKHR", "supportedAlpha", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkOffset2D(object.minSrcPosition, settings, "VkOffset2D", "minSrcPosition", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkOffset2D(object.maxSrcPosition, settings, "VkOffset2D", "maxSrcPosition", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.minSrcExtent, settings, "VkExtent2D", "minSrcExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.maxSrcExtent, settings, "VkExtent2D", "maxSrcExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkOffset2D(object.minDstPosition, settings, "VkOffset2D", "minDstPosition", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkOffset2D(object.maxDstPosition, settings, "VkOffset2D", "maxDstPosition", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.minDstExtent, settings, "VkExtent2D", "minDstExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.maxDstExtent, settings, "VkExtent2D", "maxDstExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDisplayPlanePropertiesKHR(const VkDisplayPlanePropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkDisplayKHR(object.currentDisplay, settings, "VkDisplayKHR", "currentDisplay", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.currentStackIndex, settings, "uint32_t", "currentStackIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDisplayPropertiesKHR(const VkDisplayPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkDisplayKHR(object.display, settings, "VkDisplayKHR", "display", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_char(object.displayName, settings, "const char*", "displayName", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.physicalDimensions, settings, "VkExtent2D", "physicalDimensions", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.physicalResolution, settings, "VkExtent2D", "physicalResolution", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSurfaceTransformFlagsKHR(object.supportedTransforms, settings, "VkSurfaceTransformFlagsKHR", "supportedTransforms", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.planeReorderPossible, settings, "VkBool32", "planeReorderPossible", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.persistentContent, settings, "VkBool32", "persistentContent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDisplaySurfaceCreateInfoKHR(const VkDisplaySurfaceCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDisplaySurfaceCreateFlagsKHR(object.flags, settings, "VkDisplaySurfaceCreateFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDisplayModeKHR(object.displayMode, settings, "VkDisplayModeKHR", "displayMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.planeIndex, settings, "uint32_t", "planeIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.planeStackIndex, settings, "uint32_t", "planeStackIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSurfaceTransformFlagBitsKHR(object.transform, settings, "VkSurfaceTransformFlagBitsKHR", "transform", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.globalAlpha, settings, "float", "globalAlpha", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDisplayPlaneAlphaFlagBitsKHR(object.alphaMode, settings, "VkDisplayPlaneAlphaFlagBitsKHR", "alphaMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.imageExtent, settings, "VkExtent2D", "imageExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDisplayPresentInfoKHR(const VkDisplayPresentInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkRect2D(object.srcRect, settings, "VkRect2D", "srcRect", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkRect2D(object.dstRect, settings, "VkRect2D", "dstRect", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.persistent, settings, "VkBool32", "persistent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#if defined(VK_USE_PLATFORM_XLIB_KHR) +template +void dump_VkXlibSurfaceCreateInfoKHR(const VkXlibSurfaceCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkXlibSurfaceCreateFlagsKHR(object.flags, settings, "VkXlibSurfaceCreateFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dpy, settings, "Display*", "dpy", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.window, settings, "Window", "window", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#endif // VK_USE_PLATFORM_XLIB_KHR +#if defined(VK_USE_PLATFORM_XCB_KHR) +template +void dump_VkXcbSurfaceCreateInfoKHR(const VkXcbSurfaceCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkXcbSurfaceCreateFlagsKHR(object.flags, settings, "VkXcbSurfaceCreateFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.connection, settings, "xcb_connection_t*", "connection", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_uint64_t_as_pointer(object.window, settings, "xcb_window_t", "window", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#endif // VK_USE_PLATFORM_XCB_KHR +#if defined(VK_USE_PLATFORM_WAYLAND_KHR) +template +void dump_VkWaylandSurfaceCreateInfoKHR(const VkWaylandSurfaceCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkWaylandSurfaceCreateFlagsKHR(object.flags, settings, "VkWaylandSurfaceCreateFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.display, settings, "struct wl_display*", "display", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.surface, settings, "struct wl_surface*", "surface", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#endif // VK_USE_PLATFORM_WAYLAND_KHR +#if defined(VK_USE_PLATFORM_ANDROID_KHR) +template +void dump_VkAndroidSurfaceCreateInfoKHR(const VkAndroidSurfaceCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAndroidSurfaceCreateFlagsKHR(object.flags, settings, "VkAndroidSurfaceCreateFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.window, settings, "struct ANativeWindow*", "window", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#endif // VK_USE_PLATFORM_ANDROID_KHR +#if defined(VK_USE_PLATFORM_WIN32_KHR) +template +void dump_VkWin32SurfaceCreateInfoKHR(const VkWin32SurfaceCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkWin32SurfaceCreateFlagsKHR(object.flags, settings, "VkWin32SurfaceCreateFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.hinstance, settings, "HINSTANCE", "hinstance", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.hwnd, settings, "HWND", "hwnd", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#endif // VK_USE_PLATFORM_WIN32_KHR +template +void dump_VkQueueFamilyQueryResultStatusPropertiesKHR(const VkQueueFamilyQueryResultStatusPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.queryResultStatusSupport, settings, "VkBool32", "queryResultStatusSupport", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkQueueFamilyVideoPropertiesKHR(const VkQueueFamilyVideoPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoCodecOperationFlagsKHR(object.videoCodecOperations, settings, "VkVideoCodecOperationFlagsKHR", "videoCodecOperations", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoProfileInfoKHR(const VkVideoProfileInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoCodecOperationFlagBitsKHR(object.videoCodecOperation, settings, "VkVideoCodecOperationFlagBitsKHR", "videoCodecOperation", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoChromaSubsamplingFlagsKHR(object.chromaSubsampling, settings, "VkVideoChromaSubsamplingFlagsKHR", "chromaSubsampling", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoComponentBitDepthFlagsKHR(object.lumaBitDepth, settings, "VkVideoComponentBitDepthFlagsKHR", "lumaBitDepth", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoComponentBitDepthFlagsKHR(object.chromaBitDepth, settings, "VkVideoComponentBitDepthFlagsKHR", "chromaBitDepth", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoProfileListInfoKHR(const VkVideoProfileListInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.profileCount, settings, "uint32_t", "profileCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pProfiles, object.profileCount, settings, "const VkVideoProfileInfoKHR*", "pProfiles", "const VkVideoProfileInfoKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoProfileInfoKHR); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoCapabilitiesKHR(const VkVideoCapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoCapabilityFlagsKHR(object.flags, settings, "VkVideoCapabilityFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minBitstreamBufferOffsetAlignment, settings, "VkDeviceSize", "minBitstreamBufferOffsetAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minBitstreamBufferSizeAlignment, settings, "VkDeviceSize", "minBitstreamBufferSizeAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.pictureAccessGranularity, settings, "VkExtent2D", "pictureAccessGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.minCodedExtent, settings, "VkExtent2D", "minCodedExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.maxCodedExtent, settings, "VkExtent2D", "maxCodedExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDpbSlots, settings, "uint32_t", "maxDpbSlots", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxActiveReferencePictures, settings, "uint32_t", "maxActiveReferencePictures", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtensionProperties(object.stdHeaderVersion, settings, "VkExtensionProperties", "stdHeaderVersion", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceVideoFormatInfoKHR(const VkPhysicalDeviceVideoFormatInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageUsageFlags(object.imageUsage, settings, "VkImageUsageFlags", "imageUsage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoFormatPropertiesKHR(const VkVideoFormatPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormat(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkComponentMapping(object.componentMapping, settings, "VkComponentMapping", "componentMapping", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageCreateFlags(object.imageCreateFlags, settings, "VkImageCreateFlags", "imageCreateFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageType(object.imageType, settings, "VkImageType", "imageType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageTiling(object.imageTiling, settings, "VkImageTiling", "imageTiling", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageUsageFlags(object.imageUsageFlags, settings, "VkImageUsageFlags", "imageUsageFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoPictureResourceInfoKHR(const VkVideoPictureResourceInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkOffset2D(object.codedOffset, settings, "VkOffset2D", "codedOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.codedExtent, settings, "VkExtent2D", "codedExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.baseArrayLayer, settings, "uint32_t", "baseArrayLayer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageView(object.imageViewBinding, settings, "VkImageView", "imageViewBinding", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoReferenceSlotInfoKHR(const VkVideoReferenceSlotInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.slotIndex, settings, "int32_t", "slotIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pPictureResource, settings, "const VkVideoPictureResourceInfoKHR*", "pPictureResource", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoPictureResourceInfoKHR); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoSessionMemoryRequirementsKHR(const VkVideoSessionMemoryRequirementsKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.memoryBindIndex, settings, "uint32_t", "memoryBindIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkMemoryRequirements(object.memoryRequirements, settings, "VkMemoryRequirements", "memoryRequirements", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBindVideoSessionMemoryInfoKHR(const VkBindVideoSessionMemoryInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.memoryBindIndex, settings, "uint32_t", "memoryBindIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceMemory(object.memory, settings, "VkDeviceMemory", "memory", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.memoryOffset, settings, "VkDeviceSize", "memoryOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.memorySize, settings, "VkDeviceSize", "memorySize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoSessionCreateInfoKHR(const VkVideoSessionCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoSessionCreateFlagsKHR(object.flags, settings, "VkVideoSessionCreateFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pVideoProfile, settings, "const VkVideoProfileInfoKHR*", "pVideoProfile", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoProfileInfoKHR); + dump_separate_members(settings); + dump_VkFormat(object.pictureFormat, settings, "VkFormat", "pictureFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.maxCodedExtent, settings, "VkExtent2D", "maxCodedExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormat(object.referencePictureFormat, settings, "VkFormat", "referencePictureFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDpbSlots, settings, "uint32_t", "maxDpbSlots", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxActiveReferencePictures, settings, "uint32_t", "maxActiveReferencePictures", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pStdHeaderVersion, settings, "const VkExtensionProperties*", "pStdHeaderVersion", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkExtensionProperties); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoSessionParametersCreateInfoKHR(const VkVideoSessionParametersCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoSessionParametersCreateFlagsKHR(object.flags, settings, "VkVideoSessionParametersCreateFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoSessionParametersKHR(object.videoSessionParametersTemplate, settings, "VkVideoSessionParametersKHR", "videoSessionParametersTemplate", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoSessionKHR(object.videoSession, settings, "VkVideoSessionKHR", "videoSession", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoSessionParametersUpdateInfoKHR(const VkVideoSessionParametersUpdateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.updateSequenceCount, settings, "uint32_t", "updateSequenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoBeginCodingInfoKHR(const VkVideoBeginCodingInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoBeginCodingFlagsKHR(object.flags, settings, "VkVideoBeginCodingFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoSessionKHR(object.videoSession, settings, "VkVideoSessionKHR", "videoSession", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoSessionParametersKHR(object.videoSessionParameters, settings, "VkVideoSessionParametersKHR", "videoSessionParameters", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.referenceSlotCount, settings, "uint32_t", "referenceSlotCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pReferenceSlots, object.referenceSlotCount, settings, "const VkVideoReferenceSlotInfoKHR*", "pReferenceSlots", "const VkVideoReferenceSlotInfoKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoReferenceSlotInfoKHR); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEndCodingInfoKHR(const VkVideoEndCodingInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEndCodingFlagsKHR(object.flags, settings, "VkVideoEndCodingFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoCodingControlInfoKHR(const VkVideoCodingControlInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoCodingControlFlagsKHR(object.flags, settings, "VkVideoCodingControlFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoDecodeCapabilitiesKHR(const VkVideoDecodeCapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoDecodeCapabilityFlagsKHR(object.flags, settings, "VkVideoDecodeCapabilityFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoDecodeUsageInfoKHR(const VkVideoDecodeUsageInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoDecodeUsageFlagsKHR(object.videoUsageHints, settings, "VkVideoDecodeUsageFlagsKHR", "videoUsageHints", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoDecodeInfoKHR(const VkVideoDecodeInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoDecodeFlagsKHR(object.flags, settings, "VkVideoDecodeFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBuffer(object.srcBuffer, settings, "VkBuffer", "srcBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.srcBufferOffset, settings, "VkDeviceSize", "srcBufferOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.srcBufferRange, settings, "VkDeviceSize", "srcBufferRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoPictureResourceInfoKHR(object.dstPictureResource, settings, "VkVideoPictureResourceInfoKHR", "dstPictureResource", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pSetupReferenceSlot, settings, "const VkVideoReferenceSlotInfoKHR*", "pSetupReferenceSlot", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoReferenceSlotInfoKHR); + dump_separate_members(settings); + dump_type(object.referenceSlotCount, settings, "uint32_t", "referenceSlotCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pReferenceSlots, object.referenceSlotCount, settings, "const VkVideoReferenceSlotInfoKHR*", "pReferenceSlots", "const VkVideoReferenceSlotInfoKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoReferenceSlotInfoKHR); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeH264CapabilitiesKHR(const VkVideoEncodeH264CapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeH264CapabilityFlagsKHR(object.flags, settings, "VkVideoEncodeH264CapabilityFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoH264LevelIdc(object.maxLevelIdc, settings, "StdVideoH264LevelIdc", "maxLevelIdc", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxSliceCount, settings, "uint32_t", "maxSliceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPPictureL0ReferenceCount, settings, "uint32_t", "maxPPictureL0ReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxBPictureL0ReferenceCount, settings, "uint32_t", "maxBPictureL0ReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxL1ReferenceCount, settings, "uint32_t", "maxL1ReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxTemporalLayerCount, settings, "uint32_t", "maxTemporalLayerCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.expectDyadicTemporalLayerPattern, settings, "VkBool32", "expectDyadicTemporalLayerPattern", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minQp, settings, "int32_t", "minQp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxQp, settings, "int32_t", "maxQp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.prefersGopRemainingFrames, settings, "VkBool32", "prefersGopRemainingFrames", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.requiresGopRemainingFrames, settings, "VkBool32", "requiresGopRemainingFrames", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeH264StdFlagsKHR(object.stdSyntaxFlags, settings, "VkVideoEncodeH264StdFlagsKHR", "stdSyntaxFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeH264QpKHR(const VkVideoEncodeH264QpKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.qpI, settings, "int32_t", "qpI", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.qpP, settings, "int32_t", "qpP", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.qpB, settings, "int32_t", "qpB", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeH264QualityLevelPropertiesKHR(const VkVideoEncodeH264QualityLevelPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeH264RateControlFlagsKHR(object.preferredRateControlFlags, settings, "VkVideoEncodeH264RateControlFlagsKHR", "preferredRateControlFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.preferredGopFrameCount, settings, "uint32_t", "preferredGopFrameCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.preferredIdrPeriod, settings, "uint32_t", "preferredIdrPeriod", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.preferredConsecutiveBFrameCount, settings, "uint32_t", "preferredConsecutiveBFrameCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.preferredTemporalLayerCount, settings, "uint32_t", "preferredTemporalLayerCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeH264QpKHR(object.preferredConstantQp, settings, "VkVideoEncodeH264QpKHR", "preferredConstantQp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.preferredMaxL0ReferenceCount, settings, "uint32_t", "preferredMaxL0ReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.preferredMaxL1ReferenceCount, settings, "uint32_t", "preferredMaxL1ReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.preferredStdEntropyCodingModeFlag, settings, "VkBool32", "preferredStdEntropyCodingModeFlag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeH264SessionCreateInfoKHR(const VkVideoEncodeH264SessionCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.useMaxLevelIdc, settings, "VkBool32", "useMaxLevelIdc", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoH264LevelIdc(object.maxLevelIdc, settings, "StdVideoH264LevelIdc", "maxLevelIdc", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeH264SessionParametersAddInfoKHR(const VkVideoEncodeH264SessionParametersAddInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.stdSPSCount, settings, "uint32_t", "stdSPSCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pStdSPSs, object.stdSPSCount, settings, "const StdVideoH264SequenceParameterSet*", "pStdSPSs", "const StdVideoH264SequenceParameterSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH264SequenceParameterSet); + dump_separate_members(settings); + dump_type(object.stdPPSCount, settings, "uint32_t", "stdPPSCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pStdPPSs, object.stdPPSCount, settings, "const StdVideoH264PictureParameterSet*", "pStdPPSs", "const StdVideoH264PictureParameterSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH264PictureParameterSet); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeH264SessionParametersCreateInfoKHR(const VkVideoEncodeH264SessionParametersCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxStdSPSCount, settings, "uint32_t", "maxStdSPSCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxStdPPSCount, settings, "uint32_t", "maxStdPPSCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pParametersAddInfo, settings, "const VkVideoEncodeH264SessionParametersAddInfoKHR*", "pParametersAddInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoEncodeH264SessionParametersAddInfoKHR); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeH264SessionParametersGetInfoKHR(const VkVideoEncodeH264SessionParametersGetInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.writeStdSPS, settings, "VkBool32", "writeStdSPS", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.writeStdPPS, settings, "VkBool32", "writeStdPPS", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.stdSPSId, settings, "uint32_t", "stdSPSId", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.stdPPSId, settings, "uint32_t", "stdPPSId", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeH264SessionParametersFeedbackInfoKHR(const VkVideoEncodeH264SessionParametersFeedbackInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.hasStdSPSOverrides, settings, "VkBool32", "hasStdSPSOverrides", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.hasStdPPSOverrides, settings, "VkBool32", "hasStdPPSOverrides", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeH264NaluSliceInfoKHR(const VkVideoEncodeH264NaluSliceInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.constantQp, settings, "int32_t", "constantQp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pStdSliceHeader, settings, "const StdVideoEncodeH264SliceHeader*", "pStdSliceHeader", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeH264SliceHeader); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeH264PictureInfoKHR(const VkVideoEncodeH264PictureInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.naluSliceEntryCount, settings, "uint32_t", "naluSliceEntryCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pNaluSliceEntries, object.naluSliceEntryCount, settings, "const VkVideoEncodeH264NaluSliceInfoKHR*", "pNaluSliceEntries", "const VkVideoEncodeH264NaluSliceInfoKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoEncodeH264NaluSliceInfoKHR); + dump_separate_members(settings); + dump_pointer(object.pStdPictureInfo, settings, "const StdVideoEncodeH264PictureInfo*", "pStdPictureInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeH264PictureInfo); + dump_separate_members(settings); + dump_type(object.generatePrefixNalu, settings, "VkBool32", "generatePrefixNalu", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeH264DpbSlotInfoKHR(const VkVideoEncodeH264DpbSlotInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pStdReferenceInfo, settings, "const StdVideoEncodeH264ReferenceInfo*", "pStdReferenceInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeH264ReferenceInfo); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeH264ProfileInfoKHR(const VkVideoEncodeH264ProfileInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoH264ProfileIdc(object.stdProfileIdc, settings, "StdVideoH264ProfileIdc", "stdProfileIdc", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeH264RateControlInfoKHR(const VkVideoEncodeH264RateControlInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeH264RateControlFlagsKHR(object.flags, settings, "VkVideoEncodeH264RateControlFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.gopFrameCount, settings, "uint32_t", "gopFrameCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.idrPeriod, settings, "uint32_t", "idrPeriod", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.consecutiveBFrameCount, settings, "uint32_t", "consecutiveBFrameCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.temporalLayerCount, settings, "uint32_t", "temporalLayerCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeH264FrameSizeKHR(const VkVideoEncodeH264FrameSizeKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.frameISize, settings, "uint32_t", "frameISize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.framePSize, settings, "uint32_t", "framePSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.frameBSize, settings, "uint32_t", "frameBSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeH264RateControlLayerInfoKHR(const VkVideoEncodeH264RateControlLayerInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.useMinQp, settings, "VkBool32", "useMinQp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeH264QpKHR(object.minQp, settings, "VkVideoEncodeH264QpKHR", "minQp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.useMaxQp, settings, "VkBool32", "useMaxQp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeH264QpKHR(object.maxQp, settings, "VkVideoEncodeH264QpKHR", "maxQp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.useMaxFrameSize, settings, "VkBool32", "useMaxFrameSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeH264FrameSizeKHR(object.maxFrameSize, settings, "VkVideoEncodeH264FrameSizeKHR", "maxFrameSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeH264GopRemainingFrameInfoKHR(const VkVideoEncodeH264GopRemainingFrameInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.useGopRemainingFrames, settings, "VkBool32", "useGopRemainingFrames", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.gopRemainingI, settings, "uint32_t", "gopRemainingI", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.gopRemainingP, settings, "uint32_t", "gopRemainingP", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.gopRemainingB, settings, "uint32_t", "gopRemainingB", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeH265CapabilitiesKHR(const VkVideoEncodeH265CapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeH265CapabilityFlagsKHR(object.flags, settings, "VkVideoEncodeH265CapabilityFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoH265LevelIdc(object.maxLevelIdc, settings, "StdVideoH265LevelIdc", "maxLevelIdc", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxSliceSegmentCount, settings, "uint32_t", "maxSliceSegmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.maxTiles, settings, "VkExtent2D", "maxTiles", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeH265CtbSizeFlagsKHR(object.ctbSizes, settings, "VkVideoEncodeH265CtbSizeFlagsKHR", "ctbSizes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeH265TransformBlockSizeFlagsKHR(object.transformBlockSizes, settings, "VkVideoEncodeH265TransformBlockSizeFlagsKHR", "transformBlockSizes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPPictureL0ReferenceCount, settings, "uint32_t", "maxPPictureL0ReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxBPictureL0ReferenceCount, settings, "uint32_t", "maxBPictureL0ReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxL1ReferenceCount, settings, "uint32_t", "maxL1ReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxSubLayerCount, settings, "uint32_t", "maxSubLayerCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.expectDyadicTemporalSubLayerPattern, settings, "VkBool32", "expectDyadicTemporalSubLayerPattern", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minQp, settings, "int32_t", "minQp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxQp, settings, "int32_t", "maxQp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.prefersGopRemainingFrames, settings, "VkBool32", "prefersGopRemainingFrames", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.requiresGopRemainingFrames, settings, "VkBool32", "requiresGopRemainingFrames", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeH265StdFlagsKHR(object.stdSyntaxFlags, settings, "VkVideoEncodeH265StdFlagsKHR", "stdSyntaxFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeH265SessionCreateInfoKHR(const VkVideoEncodeH265SessionCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.useMaxLevelIdc, settings, "VkBool32", "useMaxLevelIdc", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoH265LevelIdc(object.maxLevelIdc, settings, "StdVideoH265LevelIdc", "maxLevelIdc", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeH265QpKHR(const VkVideoEncodeH265QpKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.qpI, settings, "int32_t", "qpI", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.qpP, settings, "int32_t", "qpP", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.qpB, settings, "int32_t", "qpB", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeH265QualityLevelPropertiesKHR(const VkVideoEncodeH265QualityLevelPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeH265RateControlFlagsKHR(object.preferredRateControlFlags, settings, "VkVideoEncodeH265RateControlFlagsKHR", "preferredRateControlFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.preferredGopFrameCount, settings, "uint32_t", "preferredGopFrameCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.preferredIdrPeriod, settings, "uint32_t", "preferredIdrPeriod", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.preferredConsecutiveBFrameCount, settings, "uint32_t", "preferredConsecutiveBFrameCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.preferredSubLayerCount, settings, "uint32_t", "preferredSubLayerCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeH265QpKHR(object.preferredConstantQp, settings, "VkVideoEncodeH265QpKHR", "preferredConstantQp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.preferredMaxL0ReferenceCount, settings, "uint32_t", "preferredMaxL0ReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.preferredMaxL1ReferenceCount, settings, "uint32_t", "preferredMaxL1ReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeH265SessionParametersAddInfoKHR(const VkVideoEncodeH265SessionParametersAddInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.stdVPSCount, settings, "uint32_t", "stdVPSCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pStdVPSs, object.stdVPSCount, settings, "const StdVideoH265VideoParameterSet*", "pStdVPSs", "const StdVideoH265VideoParameterSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265VideoParameterSet); + dump_separate_members(settings); + dump_type(object.stdSPSCount, settings, "uint32_t", "stdSPSCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pStdSPSs, object.stdSPSCount, settings, "const StdVideoH265SequenceParameterSet*", "pStdSPSs", "const StdVideoH265SequenceParameterSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265SequenceParameterSet); + dump_separate_members(settings); + dump_type(object.stdPPSCount, settings, "uint32_t", "stdPPSCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pStdPPSs, object.stdPPSCount, settings, "const StdVideoH265PictureParameterSet*", "pStdPPSs", "const StdVideoH265PictureParameterSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265PictureParameterSet); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeH265SessionParametersCreateInfoKHR(const VkVideoEncodeH265SessionParametersCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxStdVPSCount, settings, "uint32_t", "maxStdVPSCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxStdSPSCount, settings, "uint32_t", "maxStdSPSCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxStdPPSCount, settings, "uint32_t", "maxStdPPSCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pParametersAddInfo, settings, "const VkVideoEncodeH265SessionParametersAddInfoKHR*", "pParametersAddInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoEncodeH265SessionParametersAddInfoKHR); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeH265SessionParametersGetInfoKHR(const VkVideoEncodeH265SessionParametersGetInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.writeStdVPS, settings, "VkBool32", "writeStdVPS", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.writeStdSPS, settings, "VkBool32", "writeStdSPS", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.writeStdPPS, settings, "VkBool32", "writeStdPPS", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.stdVPSId, settings, "uint32_t", "stdVPSId", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.stdSPSId, settings, "uint32_t", "stdSPSId", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.stdPPSId, settings, "uint32_t", "stdPPSId", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeH265SessionParametersFeedbackInfoKHR(const VkVideoEncodeH265SessionParametersFeedbackInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.hasStdVPSOverrides, settings, "VkBool32", "hasStdVPSOverrides", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.hasStdSPSOverrides, settings, "VkBool32", "hasStdSPSOverrides", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.hasStdPPSOverrides, settings, "VkBool32", "hasStdPPSOverrides", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeH265NaluSliceSegmentInfoKHR(const VkVideoEncodeH265NaluSliceSegmentInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.constantQp, settings, "int32_t", "constantQp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pStdSliceSegmentHeader, settings, "const StdVideoEncodeH265SliceSegmentHeader*", "pStdSliceSegmentHeader", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeH265SliceSegmentHeader); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeH265PictureInfoKHR(const VkVideoEncodeH265PictureInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.naluSliceSegmentEntryCount, settings, "uint32_t", "naluSliceSegmentEntryCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pNaluSliceSegmentEntries, object.naluSliceSegmentEntryCount, settings, "const VkVideoEncodeH265NaluSliceSegmentInfoKHR*", "pNaluSliceSegmentEntries", "const VkVideoEncodeH265NaluSliceSegmentInfoKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoEncodeH265NaluSliceSegmentInfoKHR); + dump_separate_members(settings); + dump_pointer(object.pStdPictureInfo, settings, "const StdVideoEncodeH265PictureInfo*", "pStdPictureInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeH265PictureInfo); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeH265DpbSlotInfoKHR(const VkVideoEncodeH265DpbSlotInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pStdReferenceInfo, settings, "const StdVideoEncodeH265ReferenceInfo*", "pStdReferenceInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeH265ReferenceInfo); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeH265ProfileInfoKHR(const VkVideoEncodeH265ProfileInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoH265ProfileIdc(object.stdProfileIdc, settings, "StdVideoH265ProfileIdc", "stdProfileIdc", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeH265RateControlInfoKHR(const VkVideoEncodeH265RateControlInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeH265RateControlFlagsKHR(object.flags, settings, "VkVideoEncodeH265RateControlFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.gopFrameCount, settings, "uint32_t", "gopFrameCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.idrPeriod, settings, "uint32_t", "idrPeriod", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.consecutiveBFrameCount, settings, "uint32_t", "consecutiveBFrameCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.subLayerCount, settings, "uint32_t", "subLayerCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeH265FrameSizeKHR(const VkVideoEncodeH265FrameSizeKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.frameISize, settings, "uint32_t", "frameISize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.framePSize, settings, "uint32_t", "framePSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.frameBSize, settings, "uint32_t", "frameBSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeH265RateControlLayerInfoKHR(const VkVideoEncodeH265RateControlLayerInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.useMinQp, settings, "VkBool32", "useMinQp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeH265QpKHR(object.minQp, settings, "VkVideoEncodeH265QpKHR", "minQp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.useMaxQp, settings, "VkBool32", "useMaxQp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeH265QpKHR(object.maxQp, settings, "VkVideoEncodeH265QpKHR", "maxQp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.useMaxFrameSize, settings, "VkBool32", "useMaxFrameSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeH265FrameSizeKHR(object.maxFrameSize, settings, "VkVideoEncodeH265FrameSizeKHR", "maxFrameSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeH265GopRemainingFrameInfoKHR(const VkVideoEncodeH265GopRemainingFrameInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.useGopRemainingFrames, settings, "VkBool32", "useGopRemainingFrames", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.gopRemainingI, settings, "uint32_t", "gopRemainingI", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.gopRemainingP, settings, "uint32_t", "gopRemainingP", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.gopRemainingB, settings, "uint32_t", "gopRemainingB", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoDecodeH264ProfileInfoKHR(const VkVideoDecodeH264ProfileInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoH264ProfileIdc(object.stdProfileIdc, settings, "StdVideoH264ProfileIdc", "stdProfileIdc", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoDecodeH264PictureLayoutFlagBitsKHR(object.pictureLayout, settings, "VkVideoDecodeH264PictureLayoutFlagBitsKHR", "pictureLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoDecodeH264CapabilitiesKHR(const VkVideoDecodeH264CapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoH264LevelIdc(object.maxLevelIdc, settings, "StdVideoH264LevelIdc", "maxLevelIdc", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkOffset2D(object.fieldOffsetGranularity, settings, "VkOffset2D", "fieldOffsetGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoDecodeH264SessionParametersAddInfoKHR(const VkVideoDecodeH264SessionParametersAddInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.stdSPSCount, settings, "uint32_t", "stdSPSCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pStdSPSs, object.stdSPSCount, settings, "const StdVideoH264SequenceParameterSet*", "pStdSPSs", "const StdVideoH264SequenceParameterSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH264SequenceParameterSet); + dump_separate_members(settings); + dump_type(object.stdPPSCount, settings, "uint32_t", "stdPPSCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pStdPPSs, object.stdPPSCount, settings, "const StdVideoH264PictureParameterSet*", "pStdPPSs", "const StdVideoH264PictureParameterSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH264PictureParameterSet); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoDecodeH264SessionParametersCreateInfoKHR(const VkVideoDecodeH264SessionParametersCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxStdSPSCount, settings, "uint32_t", "maxStdSPSCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxStdPPSCount, settings, "uint32_t", "maxStdPPSCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pParametersAddInfo, settings, "const VkVideoDecodeH264SessionParametersAddInfoKHR*", "pParametersAddInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoDecodeH264SessionParametersAddInfoKHR); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoDecodeH264PictureInfoKHR(const VkVideoDecodeH264PictureInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pStdPictureInfo, settings, "const StdVideoDecodeH264PictureInfo*", "pStdPictureInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoDecodeH264PictureInfo); + dump_separate_members(settings); + dump_type(object.sliceCount, settings, "uint32_t", "sliceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pSliceOffsets, object.sliceCount, settings, "const uint32_t*", "pSliceOffsets", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoDecodeH264DpbSlotInfoKHR(const VkVideoDecodeH264DpbSlotInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pStdReferenceInfo, settings, "const StdVideoDecodeH264ReferenceInfo*", "pStdReferenceInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoDecodeH264ReferenceInfo); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#if defined(VK_USE_PLATFORM_WIN32_KHR) +template +void dump_VkImportMemoryWin32HandleInfoKHR(const VkImportMemoryWin32HandleInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalMemoryHandleTypeFlagBits(object.handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.handle, settings, "HANDLE", "handle", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.name, settings, "LPCWSTR", "name", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkExportMemoryWin32HandleInfoKHR(const VkExportMemoryWin32HandleInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pAttributes, settings, "const SECURITY_ATTRIBUTES*", "pAttributes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dwAccess, settings, "DWORD", "dwAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.name, settings, "LPCWSTR", "name", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMemoryWin32HandlePropertiesKHR(const VkMemoryWin32HandlePropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.memoryTypeBits, settings, "uint32_t", "memoryTypeBits", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMemoryGetWin32HandleInfoKHR(const VkMemoryGetWin32HandleInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceMemory(object.memory, settings, "VkDeviceMemory", "memory", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalMemoryHandleTypeFlagBits(object.handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#endif // VK_USE_PLATFORM_WIN32_KHR +template +void dump_VkImportMemoryFdInfoKHR(const VkImportMemoryFdInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalMemoryHandleTypeFlagBits(object.handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.fd, settings, "int", "fd", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMemoryFdPropertiesKHR(const VkMemoryFdPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.memoryTypeBits, settings, "uint32_t", "memoryTypeBits", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMemoryGetFdInfoKHR(const VkMemoryGetFdInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceMemory(object.memory, settings, "VkDeviceMemory", "memory", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalMemoryHandleTypeFlagBits(object.handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#if defined(VK_USE_PLATFORM_WIN32_KHR) +template +void dump_VkWin32KeyedMutexAcquireReleaseInfoKHR(const VkWin32KeyedMutexAcquireReleaseInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.acquireCount, settings, "uint32_t", "acquireCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pAcquireSyncs, object.acquireCount, settings, "const VkDeviceMemory*", "pAcquireSyncs", "const VkDeviceMemory", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDeviceMemory); + dump_separate_members(settings); + dump_pointer_array(object.pAcquireKeys, object.acquireCount, settings, "const uint64_t*", "pAcquireKeys", "const uint64_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(object.pAcquireTimeouts, object.acquireCount, settings, "const uint32_t*", "pAcquireTimeouts", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.releaseCount, settings, "uint32_t", "releaseCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pReleaseSyncs, object.releaseCount, settings, "const VkDeviceMemory*", "pReleaseSyncs", "const VkDeviceMemory", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDeviceMemory); + dump_separate_members(settings); + dump_pointer_array(object.pReleaseKeys, object.releaseCount, settings, "const uint64_t*", "pReleaseKeys", "const uint64_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImportSemaphoreWin32HandleInfoKHR(const VkImportSemaphoreWin32HandleInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSemaphore(object.semaphore, settings, "VkSemaphore", "semaphore", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSemaphoreImportFlags(object.flags, settings, "VkSemaphoreImportFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalSemaphoreHandleTypeFlagBits(object.handleType, settings, "VkExternalSemaphoreHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.handle, settings, "HANDLE", "handle", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.name, settings, "LPCWSTR", "name", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkExportSemaphoreWin32HandleInfoKHR(const VkExportSemaphoreWin32HandleInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pAttributes, settings, "const SECURITY_ATTRIBUTES*", "pAttributes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dwAccess, settings, "DWORD", "dwAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.name, settings, "LPCWSTR", "name", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkD3D12FenceSubmitInfoKHR(const VkD3D12FenceSubmitInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.waitSemaphoreValuesCount, settings, "uint32_t", "waitSemaphoreValuesCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pWaitSemaphoreValues, object.waitSemaphoreValuesCount, settings, "const uint64_t*", "pWaitSemaphoreValues", "const uint64_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.signalSemaphoreValuesCount, settings, "uint32_t", "signalSemaphoreValuesCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pSignalSemaphoreValues, object.signalSemaphoreValuesCount, settings, "const uint64_t*", "pSignalSemaphoreValues", "const uint64_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSemaphoreGetWin32HandleInfoKHR(const VkSemaphoreGetWin32HandleInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSemaphore(object.semaphore, settings, "VkSemaphore", "semaphore", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalSemaphoreHandleTypeFlagBits(object.handleType, settings, "VkExternalSemaphoreHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#endif // VK_USE_PLATFORM_WIN32_KHR +template +void dump_VkImportSemaphoreFdInfoKHR(const VkImportSemaphoreFdInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSemaphore(object.semaphore, settings, "VkSemaphore", "semaphore", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSemaphoreImportFlags(object.flags, settings, "VkSemaphoreImportFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalSemaphoreHandleTypeFlagBits(object.handleType, settings, "VkExternalSemaphoreHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.fd, settings, "int", "fd", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSemaphoreGetFdInfoKHR(const VkSemaphoreGetFdInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSemaphore(object.semaphore, settings, "VkSemaphore", "semaphore", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalSemaphoreHandleTypeFlagBits(object.handleType, settings, "VkExternalSemaphoreHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkRectLayerKHR(const VkRectLayerKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkOffset2D(object.offset, settings, "VkOffset2D", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.extent, settings, "VkExtent2D", "extent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.layer, settings, "uint32_t", "layer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPresentRegionKHR(const VkPresentRegionKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.rectangleCount, settings, "uint32_t", "rectangleCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pRectangles, object.rectangleCount, settings, "const VkRectLayerKHR*", "pRectangles", "const VkRectLayerKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkRectLayerKHR); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPresentRegionsKHR(const VkPresentRegionsKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.swapchainCount, settings, "uint32_t", "swapchainCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pRegions, object.swapchainCount, settings, "const VkPresentRegionKHR*", "pRegions", "const VkPresentRegionKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPresentRegionKHR); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSharedPresentSurfaceCapabilitiesKHR(const VkSharedPresentSurfaceCapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageUsageFlags(object.sharedPresentSupportedUsageFlags, settings, "VkImageUsageFlags", "sharedPresentSupportedUsageFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#if defined(VK_USE_PLATFORM_WIN32_KHR) +template +void dump_VkImportFenceWin32HandleInfoKHR(const VkImportFenceWin32HandleInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFence(object.fence, settings, "VkFence", "fence", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFenceImportFlags(object.flags, settings, "VkFenceImportFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalFenceHandleTypeFlagBits(object.handleType, settings, "VkExternalFenceHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.handle, settings, "HANDLE", "handle", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.name, settings, "LPCWSTR", "name", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkExportFenceWin32HandleInfoKHR(const VkExportFenceWin32HandleInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pAttributes, settings, "const SECURITY_ATTRIBUTES*", "pAttributes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dwAccess, settings, "DWORD", "dwAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.name, settings, "LPCWSTR", "name", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkFenceGetWin32HandleInfoKHR(const VkFenceGetWin32HandleInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFence(object.fence, settings, "VkFence", "fence", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalFenceHandleTypeFlagBits(object.handleType, settings, "VkExternalFenceHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#endif // VK_USE_PLATFORM_WIN32_KHR +template +void dump_VkImportFenceFdInfoKHR(const VkImportFenceFdInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFence(object.fence, settings, "VkFence", "fence", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFenceImportFlags(object.flags, settings, "VkFenceImportFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalFenceHandleTypeFlagBits(object.handleType, settings, "VkExternalFenceHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.fd, settings, "int", "fd", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkFenceGetFdInfoKHR(const VkFenceGetFdInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFence(object.fence, settings, "VkFence", "fence", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalFenceHandleTypeFlagBits(object.handleType, settings, "VkExternalFenceHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDevicePerformanceQueryFeaturesKHR(const VkPhysicalDevicePerformanceQueryFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.performanceCounterQueryPools, settings, "VkBool32", "performanceCounterQueryPools", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.performanceCounterMultipleQueryPools, settings, "VkBool32", "performanceCounterMultipleQueryPools", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDevicePerformanceQueryPropertiesKHR(const VkPhysicalDevicePerformanceQueryPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.allowCommandBufferQueryCopies, settings, "VkBool32", "allowCommandBufferQueryCopies", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPerformanceCounterKHR(const VkPerformanceCounterKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPerformanceCounterUnitKHR(object.unit, settings, "VkPerformanceCounterUnitKHR", "unit", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPerformanceCounterScopeKHR(object.scope, settings, "VkPerformanceCounterScopeKHR", "scope", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPerformanceCounterStorageKHR(object.storage, settings, "VkPerformanceCounterStorageKHR", "storage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.uuid, VK_UUID_SIZE, settings, "uint8_t[VK_UUID_SIZE]", "uuid", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPerformanceCounterDescriptionKHR(const VkPerformanceCounterDescriptionKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPerformanceCounterDescriptionFlagsKHR(object.flags, settings, "VkPerformanceCounterDescriptionFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_char(object.name, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "name", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_char(object.category, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "category", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_char(object.description, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "description", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkQueryPoolPerformanceCreateInfoKHR(const VkQueryPoolPerformanceCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.counterIndexCount, settings, "uint32_t", "counterIndexCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pCounterIndices, object.counterIndexCount, settings, "const uint32_t*", "pCounterIndices", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPerformanceCounterResultKHR(const VkPerformanceCounterResultKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_union, type_name, var_name, indents, address); + dump_type(object.int32, settings, "int32_t", "int32", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.int64, settings, "int64_t", "int64", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.uint32, settings, "uint32_t", "uint32", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.uint64, settings, "uint64_t", "uint64", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.float32, settings, "float", "float32", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.float64, settings, "double", "float64", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAcquireProfilingLockInfoKHR(const VkAcquireProfilingLockInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAcquireProfilingLockFlagsKHR(object.flags, settings, "VkAcquireProfilingLockFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.timeout, settings, "uint64_t", "timeout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPerformanceQuerySubmitInfoKHR(const VkPerformanceQuerySubmitInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.counterPassIndex, settings, "uint32_t", "counterPassIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceSurfaceInfo2KHR(const VkPhysicalDeviceSurfaceInfo2KHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSurfaceKHR(object.surface, settings, "VkSurfaceKHR", "surface", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSurfaceCapabilities2KHR(const VkSurfaceCapabilities2KHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSurfaceCapabilitiesKHR(object.surfaceCapabilities, settings, "VkSurfaceCapabilitiesKHR", "surfaceCapabilities", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSurfaceFormat2KHR(const VkSurfaceFormat2KHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSurfaceFormatKHR(object.surfaceFormat, settings, "VkSurfaceFormatKHR", "surfaceFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDisplayProperties2KHR(const VkDisplayProperties2KHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDisplayPropertiesKHR(object.displayProperties, settings, "VkDisplayPropertiesKHR", "displayProperties", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDisplayPlaneProperties2KHR(const VkDisplayPlaneProperties2KHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDisplayPlanePropertiesKHR(object.displayPlaneProperties, settings, "VkDisplayPlanePropertiesKHR", "displayPlaneProperties", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDisplayModeProperties2KHR(const VkDisplayModeProperties2KHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDisplayModePropertiesKHR(object.displayModeProperties, settings, "VkDisplayModePropertiesKHR", "displayModeProperties", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDisplayPlaneInfo2KHR(const VkDisplayPlaneInfo2KHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDisplayModeKHR(object.mode, settings, "VkDisplayModeKHR", "mode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.planeIndex, settings, "uint32_t", "planeIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDisplayPlaneCapabilities2KHR(const VkDisplayPlaneCapabilities2KHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDisplayPlaneCapabilitiesKHR(object.capabilities, settings, "VkDisplayPlaneCapabilitiesKHR", "capabilities", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderBfloat16FeaturesKHR(const VkPhysicalDeviceShaderBfloat16FeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderBFloat16Type, settings, "VkBool32", "shaderBFloat16Type", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderBFloat16DotProduct, settings, "VkBool32", "shaderBFloat16DotProduct", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderBFloat16CooperativeMatrix, settings, "VkBool32", "shaderBFloat16CooperativeMatrix", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#if defined(VK_ENABLE_BETA_EXTENSIONS) +template +void dump_VkPhysicalDevicePortabilitySubsetFeaturesKHR(const VkPhysicalDevicePortabilitySubsetFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.constantAlphaColorBlendFactors, settings, "VkBool32", "constantAlphaColorBlendFactors", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.events, settings, "VkBool32", "events", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.imageViewFormatReinterpretation, settings, "VkBool32", "imageViewFormatReinterpretation", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.imageViewFormatSwizzle, settings, "VkBool32", "imageViewFormatSwizzle", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.imageView2DOn3DImage, settings, "VkBool32", "imageView2DOn3DImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.multisampleArrayImage, settings, "VkBool32", "multisampleArrayImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.mutableComparisonSamplers, settings, "VkBool32", "mutableComparisonSamplers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pointPolygons, settings, "VkBool32", "pointPolygons", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.samplerMipLodBias, settings, "VkBool32", "samplerMipLodBias", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.separateStencilMaskRef, settings, "VkBool32", "separateStencilMaskRef", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderSampleRateInterpolationFunctions, settings, "VkBool32", "shaderSampleRateInterpolationFunctions", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tessellationIsolines, settings, "VkBool32", "tessellationIsolines", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tessellationPointMode, settings, "VkBool32", "tessellationPointMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.triangleFans, settings, "VkBool32", "triangleFans", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vertexAttributeAccessBeyondStride, settings, "VkBool32", "vertexAttributeAccessBeyondStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDevicePortabilitySubsetPropertiesKHR(const VkPhysicalDevicePortabilitySubsetPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minVertexInputBindingStrideAlignment, settings, "uint32_t", "minVertexInputBindingStrideAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#endif // VK_ENABLE_BETA_EXTENSIONS +template +void dump_VkPhysicalDeviceShaderClockFeaturesKHR(const VkPhysicalDeviceShaderClockFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderSubgroupClock, settings, "VkBool32", "shaderSubgroupClock", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderDeviceClock, settings, "VkBool32", "shaderDeviceClock", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoDecodeH265ProfileInfoKHR(const VkVideoDecodeH265ProfileInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoH265ProfileIdc(object.stdProfileIdc, settings, "StdVideoH265ProfileIdc", "stdProfileIdc", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoDecodeH265CapabilitiesKHR(const VkVideoDecodeH265CapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoH265LevelIdc(object.maxLevelIdc, settings, "StdVideoH265LevelIdc", "maxLevelIdc", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoDecodeH265SessionParametersAddInfoKHR(const VkVideoDecodeH265SessionParametersAddInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.stdVPSCount, settings, "uint32_t", "stdVPSCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pStdVPSs, object.stdVPSCount, settings, "const StdVideoH265VideoParameterSet*", "pStdVPSs", "const StdVideoH265VideoParameterSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265VideoParameterSet); + dump_separate_members(settings); + dump_type(object.stdSPSCount, settings, "uint32_t", "stdSPSCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pStdSPSs, object.stdSPSCount, settings, "const StdVideoH265SequenceParameterSet*", "pStdSPSs", "const StdVideoH265SequenceParameterSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265SequenceParameterSet); + dump_separate_members(settings); + dump_type(object.stdPPSCount, settings, "uint32_t", "stdPPSCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pStdPPSs, object.stdPPSCount, settings, "const StdVideoH265PictureParameterSet*", "pStdPPSs", "const StdVideoH265PictureParameterSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265PictureParameterSet); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoDecodeH265SessionParametersCreateInfoKHR(const VkVideoDecodeH265SessionParametersCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxStdVPSCount, settings, "uint32_t", "maxStdVPSCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxStdSPSCount, settings, "uint32_t", "maxStdSPSCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxStdPPSCount, settings, "uint32_t", "maxStdPPSCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pParametersAddInfo, settings, "const VkVideoDecodeH265SessionParametersAddInfoKHR*", "pParametersAddInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoDecodeH265SessionParametersAddInfoKHR); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoDecodeH265PictureInfoKHR(const VkVideoDecodeH265PictureInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pStdPictureInfo, settings, "const StdVideoDecodeH265PictureInfo*", "pStdPictureInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoDecodeH265PictureInfo); + dump_separate_members(settings); + dump_type(object.sliceSegmentCount, settings, "uint32_t", "sliceSegmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pSliceSegmentOffsets, object.sliceSegmentCount, settings, "const uint32_t*", "pSliceSegmentOffsets", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoDecodeH265DpbSlotInfoKHR(const VkVideoDecodeH265DpbSlotInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pStdReferenceInfo, settings, "const StdVideoDecodeH265ReferenceInfo*", "pStdReferenceInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoDecodeH265ReferenceInfo); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkFragmentShadingRateAttachmentInfoKHR(const VkFragmentShadingRateAttachmentInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pFragmentShadingRateAttachment, settings, "const VkAttachmentReference2*", "pFragmentShadingRateAttachment", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkAttachmentReference2); + dump_separate_members(settings); + dump_VkExtent2D(object.shadingRateAttachmentTexelSize, settings, "VkExtent2D", "shadingRateAttachmentTexelSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineFragmentShadingRateStateCreateInfoKHR(const VkPipelineFragmentShadingRateStateCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.fragmentSize, settings, "VkExtent2D", "fragmentSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.combinerOps, 2, settings, "VkFragmentShadingRateCombinerOpKHR[2]", "combinerOps", "VkFragmentShadingRateCombinerOpKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkFragmentShadingRateCombinerOpKHR); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(const VkPhysicalDeviceFragmentShadingRateFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pipelineFragmentShadingRate, settings, "VkBool32", "pipelineFragmentShadingRate", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.primitiveFragmentShadingRate, settings, "VkBool32", "primitiveFragmentShadingRate", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.attachmentFragmentShadingRate, settings, "VkBool32", "attachmentFragmentShadingRate", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(const VkPhysicalDeviceFragmentShadingRatePropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.minFragmentShadingRateAttachmentTexelSize, settings, "VkExtent2D", "minFragmentShadingRateAttachmentTexelSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.maxFragmentShadingRateAttachmentTexelSize, settings, "VkExtent2D", "maxFragmentShadingRateAttachmentTexelSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxFragmentShadingRateAttachmentTexelSizeAspectRatio, settings, "uint32_t", "maxFragmentShadingRateAttachmentTexelSizeAspectRatio", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.primitiveFragmentShadingRateWithMultipleViewports, settings, "VkBool32", "primitiveFragmentShadingRateWithMultipleViewports", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.layeredShadingRateAttachments, settings, "VkBool32", "layeredShadingRateAttachments", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.fragmentShadingRateNonTrivialCombinerOps, settings, "VkBool32", "fragmentShadingRateNonTrivialCombinerOps", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.maxFragmentSize, settings, "VkExtent2D", "maxFragmentSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxFragmentSizeAspectRatio, settings, "uint32_t", "maxFragmentSizeAspectRatio", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxFragmentShadingRateCoverageSamples, settings, "uint32_t", "maxFragmentShadingRateCoverageSamples", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSampleCountFlagBits(object.maxFragmentShadingRateRasterizationSamples, settings, "VkSampleCountFlagBits", "maxFragmentShadingRateRasterizationSamples", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.fragmentShadingRateWithShaderDepthStencilWrites, settings, "VkBool32", "fragmentShadingRateWithShaderDepthStencilWrites", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.fragmentShadingRateWithSampleMask, settings, "VkBool32", "fragmentShadingRateWithSampleMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.fragmentShadingRateWithShaderSampleMask, settings, "VkBool32", "fragmentShadingRateWithShaderSampleMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.fragmentShadingRateWithConservativeRasterization, settings, "VkBool32", "fragmentShadingRateWithConservativeRasterization", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.fragmentShadingRateWithFragmentShaderInterlock, settings, "VkBool32", "fragmentShadingRateWithFragmentShaderInterlock", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.fragmentShadingRateWithCustomSampleLocations, settings, "VkBool32", "fragmentShadingRateWithCustomSampleLocations", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.fragmentShadingRateStrictMultiplyCombiner, settings, "VkBool32", "fragmentShadingRateStrictMultiplyCombiner", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceFragmentShadingRateKHR(const VkPhysicalDeviceFragmentShadingRateKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSampleCountFlags(object.sampleCounts, settings, "VkSampleCountFlags", "sampleCounts", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.fragmentSize, settings, "VkExtent2D", "fragmentSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkRenderingFragmentShadingRateAttachmentInfoKHR(const VkRenderingFragmentShadingRateAttachmentInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageView(object.imageView, settings, "VkImageView", "imageView", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(object.imageLayout, settings, "VkImageLayout", "imageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.shadingRateAttachmentTexelSize, settings, "VkExtent2D", "shadingRateAttachmentTexelSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderQuadControlFeaturesKHR(const VkPhysicalDeviceShaderQuadControlFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderQuadControl, settings, "VkBool32", "shaderQuadControl", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSurfaceProtectedCapabilitiesKHR(const VkSurfaceProtectedCapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.supportsProtected, settings, "VkBool32", "supportsProtected", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDevicePresentWaitFeaturesKHR(const VkPhysicalDevicePresentWaitFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.presentWait, settings, "VkBool32", "presentWait", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pipelineExecutableInfo, settings, "VkBool32", "pipelineExecutableInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineInfoKHR(const VkPipelineInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipeline(object.pipeline, settings, "VkPipeline", "pipeline", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineExecutablePropertiesKHR(const VkPipelineExecutablePropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkShaderStageFlags(object.stages, settings, "VkShaderStageFlags", "stages", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_char(object.name, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "name", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_char(object.description, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "description", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.subgroupSize, settings, "uint32_t", "subgroupSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineExecutableInfoKHR(const VkPipelineExecutableInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipeline(object.pipeline, settings, "VkPipeline", "pipeline", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.executableIndex, settings, "uint32_t", "executableIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineExecutableStatisticValueKHR(const VkPipelineExecutableStatisticValueKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_union, type_name, var_name, indents, address); + dump_type(object.b32, settings, "VkBool32", "b32", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.i64, settings, "int64_t", "i64", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.u64, settings, "uint64_t", "u64", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.f64, settings, "double", "f64", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineExecutableStatisticKHR(const VkPipelineExecutableStatisticKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_char(object.name, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "name", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_char(object.description, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "description", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineExecutableStatisticFormatKHR(object.format, settings, "VkPipelineExecutableStatisticFormatKHR", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineExecutableStatisticValueKHR(object.value, settings, "VkPipelineExecutableStatisticValueKHR", "value", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineExecutableInternalRepresentationKHR(const VkPipelineExecutableInternalRepresentationKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_char(object.name, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "name", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_char(object.description, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "description", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.isText, settings, "VkBool32", "isText", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dataSize, settings, "size_t", "dataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pData, settings, "void*", "pData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineLibraryCreateInfoKHR(const VkPipelineLibraryCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.libraryCount, settings, "uint32_t", "libraryCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pLibraries, object.libraryCount, settings, "const VkPipeline*", "pLibraries", "const VkPipeline", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipeline); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPresentIdKHR(const VkPresentIdKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.swapchainCount, settings, "uint32_t", "swapchainCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pPresentIds, object.swapchainCount, settings, "const uint64_t*", "pPresentIds", "const uint64_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDevicePresentIdFeaturesKHR(const VkPhysicalDevicePresentIdFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.presentId, settings, "VkBool32", "presentId", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeInfoKHR(const VkVideoEncodeInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeFlagsKHR(object.flags, settings, "VkVideoEncodeFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBuffer(object.dstBuffer, settings, "VkBuffer", "dstBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dstBufferOffset, settings, "VkDeviceSize", "dstBufferOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dstBufferRange, settings, "VkDeviceSize", "dstBufferRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoPictureResourceInfoKHR(object.srcPictureResource, settings, "VkVideoPictureResourceInfoKHR", "srcPictureResource", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pSetupReferenceSlot, settings, "const VkVideoReferenceSlotInfoKHR*", "pSetupReferenceSlot", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoReferenceSlotInfoKHR); + dump_separate_members(settings); + dump_type(object.referenceSlotCount, settings, "uint32_t", "referenceSlotCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pReferenceSlots, object.referenceSlotCount, settings, "const VkVideoReferenceSlotInfoKHR*", "pReferenceSlots", "const VkVideoReferenceSlotInfoKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoReferenceSlotInfoKHR); + dump_separate_members(settings); + dump_type(object.precedingExternallyEncodedBytes, settings, "uint32_t", "precedingExternallyEncodedBytes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeCapabilitiesKHR(const VkVideoEncodeCapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeCapabilityFlagsKHR(object.flags, settings, "VkVideoEncodeCapabilityFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeRateControlModeFlagsKHR(object.rateControlModes, settings, "VkVideoEncodeRateControlModeFlagsKHR", "rateControlModes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxRateControlLayers, settings, "uint32_t", "maxRateControlLayers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxBitrate, settings, "uint64_t", "maxBitrate", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxQualityLevels, settings, "uint32_t", "maxQualityLevels", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.encodeInputPictureGranularity, settings, "VkExtent2D", "encodeInputPictureGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeFeedbackFlagsKHR(object.supportedEncodeFeedbackFlags, settings, "VkVideoEncodeFeedbackFlagsKHR", "supportedEncodeFeedbackFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeFeedbackFlagsKHR(object.encodeFeedbackFlags, settings, "VkVideoEncodeFeedbackFlagsKHR", "encodeFeedbackFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeUsageInfoKHR(const VkVideoEncodeUsageInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeUsageFlagsKHR(object.videoUsageHints, settings, "VkVideoEncodeUsageFlagsKHR", "videoUsageHints", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeContentFlagsKHR(object.videoContentHints, settings, "VkVideoEncodeContentFlagsKHR", "videoContentHints", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeTuningModeKHR(object.tuningMode, settings, "VkVideoEncodeTuningModeKHR", "tuningMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeRateControlLayerInfoKHR(const VkVideoEncodeRateControlLayerInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.averageBitrate, settings, "uint64_t", "averageBitrate", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxBitrate, settings, "uint64_t", "maxBitrate", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.frameRateNumerator, settings, "uint32_t", "frameRateNumerator", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.frameRateDenominator, settings, "uint32_t", "frameRateDenominator", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeRateControlInfoKHR(const VkVideoEncodeRateControlInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeRateControlFlagsKHR(object.flags, settings, "VkVideoEncodeRateControlFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeRateControlModeFlagBitsKHR(object.rateControlMode, settings, "VkVideoEncodeRateControlModeFlagBitsKHR", "rateControlMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.layerCount, settings, "uint32_t", "layerCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pLayers, object.layerCount, settings, "const VkVideoEncodeRateControlLayerInfoKHR*", "pLayers", "const VkVideoEncodeRateControlLayerInfoKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoEncodeRateControlLayerInfoKHR); + dump_separate_members(settings); + dump_type(object.virtualBufferSizeInMs, settings, "uint32_t", "virtualBufferSizeInMs", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.initialVirtualBufferSizeInMs, settings, "uint32_t", "initialVirtualBufferSizeInMs", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR(const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pVideoProfile, settings, "const VkVideoProfileInfoKHR*", "pVideoProfile", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkVideoProfileInfoKHR); + dump_separate_members(settings); + dump_type(object.qualityLevel, settings, "uint32_t", "qualityLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeQualityLevelPropertiesKHR(const VkVideoEncodeQualityLevelPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeRateControlModeFlagBitsKHR(object.preferredRateControlMode, settings, "VkVideoEncodeRateControlModeFlagBitsKHR", "preferredRateControlMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.preferredRateControlLayerCount, settings, "uint32_t", "preferredRateControlLayerCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeQualityLevelInfoKHR(const VkVideoEncodeQualityLevelInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.qualityLevel, settings, "uint32_t", "qualityLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeSessionParametersGetInfoKHR(const VkVideoEncodeSessionParametersGetInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoSessionParametersKHR(object.videoSessionParameters, settings, "VkVideoSessionParametersKHR", "videoSessionParameters", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeSessionParametersFeedbackInfoKHR(const VkVideoEncodeSessionParametersFeedbackInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.hasOverrides, settings, "VkBool32", "hasOverrides", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.fragmentShaderBarycentric, settings, "VkBool32", "fragmentShaderBarycentric", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.triStripVertexOrderIndependentOfProvokingVertex, settings, "VkBool32", "triStripVertexOrderIndependentOfProvokingVertex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderSubgroupUniformControlFlow, settings, "VkBool32", "shaderSubgroupUniformControlFlow", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.workgroupMemoryExplicitLayout, settings, "VkBool32", "workgroupMemoryExplicitLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.workgroupMemoryExplicitLayoutScalarBlockLayout, settings, "VkBool32", "workgroupMemoryExplicitLayoutScalarBlockLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.workgroupMemoryExplicitLayout8BitAccess, settings, "VkBool32", "workgroupMemoryExplicitLayout8BitAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.workgroupMemoryExplicitLayout16BitAccess, settings, "VkBool32", "workgroupMemoryExplicitLayout16BitAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.rayTracingMaintenance1, settings, "VkBool32", "rayTracingMaintenance1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.rayTracingPipelineTraceRaysIndirect2, settings, "VkBool32", "rayTracingPipelineTraceRaysIndirect2", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkTraceRaysIndirectCommand2KHR(const VkTraceRaysIndirectCommand2KHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type_hex(object.raygenShaderRecordAddress, settings, "VkDeviceAddress", "raygenShaderRecordAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.raygenShaderRecordSize, settings, "VkDeviceSize", "raygenShaderRecordSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type_hex(object.missShaderBindingTableAddress, settings, "VkDeviceAddress", "missShaderBindingTableAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.missShaderBindingTableSize, settings, "VkDeviceSize", "missShaderBindingTableSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.missShaderBindingTableStride, settings, "VkDeviceSize", "missShaderBindingTableStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type_hex(object.hitShaderBindingTableAddress, settings, "VkDeviceAddress", "hitShaderBindingTableAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.hitShaderBindingTableSize, settings, "VkDeviceSize", "hitShaderBindingTableSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.hitShaderBindingTableStride, settings, "VkDeviceSize", "hitShaderBindingTableStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type_hex(object.callableShaderBindingTableAddress, settings, "VkDeviceAddress", "callableShaderBindingTableAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.callableShaderBindingTableSize, settings, "VkDeviceSize", "callableShaderBindingTableSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.callableShaderBindingTableStride, settings, "VkDeviceSize", "callableShaderBindingTableStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.width, settings, "uint32_t", "width", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.height, settings, "uint32_t", "height", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.depth, settings, "uint32_t", "depth", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderUntypedPointersFeaturesKHR(const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderUntypedPointers, settings, "VkBool32", "shaderUntypedPointers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR(const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderMaximalReconvergence, settings, "VkBool32", "shaderMaximalReconvergence", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSurfaceCapabilitiesPresentId2KHR(const VkSurfaceCapabilitiesPresentId2KHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.presentId2Supported, settings, "VkBool32", "presentId2Supported", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPresentId2KHR(const VkPresentId2KHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.swapchainCount, settings, "uint32_t", "swapchainCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pPresentIds, object.swapchainCount, settings, "const uint64_t*", "pPresentIds", "const uint64_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDevicePresentId2FeaturesKHR(const VkPhysicalDevicePresentId2FeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.presentId2, settings, "VkBool32", "presentId2", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSurfaceCapabilitiesPresentWait2KHR(const VkSurfaceCapabilitiesPresentWait2KHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.presentWait2Supported, settings, "VkBool32", "presentWait2Supported", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDevicePresentWait2FeaturesKHR(const VkPhysicalDevicePresentWait2FeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.presentWait2, settings, "VkBool32", "presentWait2", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPresentWait2InfoKHR(const VkPresentWait2InfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.presentId, settings, "uint64_t", "presentId", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.timeout, settings, "uint64_t", "timeout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.rayTracingPositionFetch, settings, "VkBool32", "rayTracingPositionFetch", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDevicePipelineBinaryFeaturesKHR(const VkPhysicalDevicePipelineBinaryFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pipelineBinaries, settings, "VkBool32", "pipelineBinaries", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDevicePipelineBinaryPropertiesKHR(const VkPhysicalDevicePipelineBinaryPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pipelineBinaryInternalCache, settings, "VkBool32", "pipelineBinaryInternalCache", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pipelineBinaryInternalCacheControl, settings, "VkBool32", "pipelineBinaryInternalCacheControl", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pipelineBinaryPrefersInternalCache, settings, "VkBool32", "pipelineBinaryPrefersInternalCache", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pipelineBinaryPrecompiledInternalCache, settings, "VkBool32", "pipelineBinaryPrecompiledInternalCache", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pipelineBinaryCompressedData, settings, "VkBool32", "pipelineBinaryCompressedData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDevicePipelineBinaryInternalCacheControlKHR(const VkDevicePipelineBinaryInternalCacheControlKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.disableInternalCache, settings, "VkBool32", "disableInternalCache", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineBinaryKeyKHR(const VkPipelineBinaryKeyKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.keySize, settings, "uint32_t", "keySize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.key, VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR, settings, "uint8_t[VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR]", "key", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineBinaryDataKHR(const VkPipelineBinaryDataKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.dataSize, settings, "size_t", "dataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pData, settings, "void*", "pData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineBinaryKeysAndDataKHR(const VkPipelineBinaryKeysAndDataKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.binaryCount, settings, "uint32_t", "binaryCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pPipelineBinaryKeys, object.binaryCount, settings, "const VkPipelineBinaryKeyKHR*", "pPipelineBinaryKeys", "const VkPipelineBinaryKeyKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineBinaryKeyKHR); + dump_separate_members(settings); + dump_pointer_array(object.pPipelineBinaryData, object.binaryCount, settings, "const VkPipelineBinaryDataKHR*", "pPipelineBinaryData", "const VkPipelineBinaryDataKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineBinaryDataKHR); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineCreateInfoKHR(const VkPipelineCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineBinaryCreateInfoKHR(const VkPipelineBinaryCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pKeysAndDataInfo, settings, "const VkPipelineBinaryKeysAndDataKHR*", "pKeysAndDataInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineBinaryKeysAndDataKHR); + dump_separate_members(settings); + dump_VkPipeline(object.pipeline, settings, "VkPipeline", "pipeline", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pPipelineCreateInfo, settings, "const VkPipelineCreateInfoKHR*", "pPipelineCreateInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineCreateInfoKHR); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineBinaryInfoKHR(const VkPipelineBinaryInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.binaryCount, settings, "uint32_t", "binaryCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pPipelineBinaries, object.binaryCount, settings, "const VkPipelineBinaryKHR*", "pPipelineBinaries", "const VkPipelineBinaryKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineBinaryKHR); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkReleaseCapturedPipelineDataInfoKHR(const VkReleaseCapturedPipelineDataInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipeline(object.pipeline, settings, "VkPipeline", "pipeline", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineBinaryDataInfoKHR(const VkPipelineBinaryDataInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineBinaryKHR(object.pipelineBinary, settings, "VkPipelineBinaryKHR", "pipelineBinary", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineBinaryHandlesInfoKHR(const VkPipelineBinaryHandlesInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pipelineBinaryCount, settings, "uint32_t", "pipelineBinaryCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pPipelineBinaries, object.pipelineBinaryCount, settings, "VkPipelineBinaryKHR*", "pPipelineBinaries", "VkPipelineBinaryKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineBinaryKHR); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSurfacePresentModeKHR(const VkSurfacePresentModeKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPresentModeKHR(object.presentMode, settings, "VkPresentModeKHR", "presentMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSurfacePresentScalingCapabilitiesKHR(const VkSurfacePresentScalingCapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPresentScalingFlagsKHR(object.supportedPresentScaling, settings, "VkPresentScalingFlagsKHR", "supportedPresentScaling", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPresentGravityFlagsKHR(object.supportedPresentGravityX, settings, "VkPresentGravityFlagsKHR", "supportedPresentGravityX", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPresentGravityFlagsKHR(object.supportedPresentGravityY, settings, "VkPresentGravityFlagsKHR", "supportedPresentGravityY", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.minScaledImageExtent, settings, "VkExtent2D", "minScaledImageExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.maxScaledImageExtent, settings, "VkExtent2D", "maxScaledImageExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSurfacePresentModeCompatibilityKHR(const VkSurfacePresentModeCompatibilityKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.presentModeCount, settings, "uint32_t", "presentModeCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pPresentModes, object.presentModeCount, settings, "VkPresentModeKHR*", "pPresentModes", "VkPresentModeKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPresentModeKHR); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR(const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.swapchainMaintenance1, settings, "VkBool32", "swapchainMaintenance1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSwapchainPresentFenceInfoKHR(const VkSwapchainPresentFenceInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.swapchainCount, settings, "uint32_t", "swapchainCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pFences, object.swapchainCount, settings, "const VkFence*", "pFences", "const VkFence", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkFence); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSwapchainPresentModesCreateInfoKHR(const VkSwapchainPresentModesCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.presentModeCount, settings, "uint32_t", "presentModeCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pPresentModes, object.presentModeCount, settings, "const VkPresentModeKHR*", "pPresentModes", "const VkPresentModeKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPresentModeKHR); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSwapchainPresentModeInfoKHR(const VkSwapchainPresentModeInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.swapchainCount, settings, "uint32_t", "swapchainCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pPresentModes, object.swapchainCount, settings, "const VkPresentModeKHR*", "pPresentModes", "const VkPresentModeKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPresentModeKHR); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSwapchainPresentScalingCreateInfoKHR(const VkSwapchainPresentScalingCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPresentScalingFlagsKHR(object.scalingBehavior, settings, "VkPresentScalingFlagsKHR", "scalingBehavior", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPresentGravityFlagsKHR(object.presentGravityX, settings, "VkPresentGravityFlagsKHR", "presentGravityX", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPresentGravityFlagsKHR(object.presentGravityY, settings, "VkPresentGravityFlagsKHR", "presentGravityY", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkReleaseSwapchainImagesInfoKHR(const VkReleaseSwapchainImagesInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSwapchainKHR(object.swapchain, settings, "VkSwapchainKHR", "swapchain", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.imageIndexCount, settings, "uint32_t", "imageIndexCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pImageIndices, object.imageIndexCount, settings, "const uint32_t*", "pImageIndices", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR(const VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.internallySynchronizedQueues, settings, "VkBool32", "internallySynchronizedQueues", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCooperativeMatrixPropertiesKHR(const VkCooperativeMatrixPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.MSize, settings, "uint32_t", "MSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.NSize, settings, "uint32_t", "NSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.KSize, settings, "uint32_t", "KSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkComponentTypeKHR(object.AType, settings, "VkComponentTypeKHR", "AType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkComponentTypeKHR(object.BType, settings, "VkComponentTypeKHR", "BType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkComponentTypeKHR(object.CType, settings, "VkComponentTypeKHR", "CType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkComponentTypeKHR(object.ResultType, settings, "VkComponentTypeKHR", "ResultType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.saturatingAccumulation, settings, "VkBool32", "saturatingAccumulation", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkScopeKHR(object.scope, settings, "VkScopeKHR", "scope", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceCooperativeMatrixFeaturesKHR(const VkPhysicalDeviceCooperativeMatrixFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.cooperativeMatrix, settings, "VkBool32", "cooperativeMatrix", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.cooperativeMatrixRobustBufferAccess, settings, "VkBool32", "cooperativeMatrixRobustBufferAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceCooperativeMatrixPropertiesKHR(const VkPhysicalDeviceCooperativeMatrixPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkShaderStageFlags(object.cooperativeMatrixSupportedStages, settings, "VkShaderStageFlags", "cooperativeMatrixSupportedStages", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR(const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.computeDerivativeGroupQuads, settings, "VkBool32", "computeDerivativeGroupQuads", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.computeDerivativeGroupLinear, settings, "VkBool32", "computeDerivativeGroupLinear", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR(const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.meshAndTaskShaderDerivatives, settings, "VkBool32", "meshAndTaskShaderDerivatives", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoDecodeAV1ProfileInfoKHR(const VkVideoDecodeAV1ProfileInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoAV1Profile(object.stdProfile, settings, "StdVideoAV1Profile", "stdProfile", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.filmGrainSupport, settings, "VkBool32", "filmGrainSupport", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoDecodeAV1CapabilitiesKHR(const VkVideoDecodeAV1CapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoAV1Level(object.maxLevel, settings, "StdVideoAV1Level", "maxLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoDecodeAV1SessionParametersCreateInfoKHR(const VkVideoDecodeAV1SessionParametersCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pStdSequenceHeader, settings, "const StdVideoAV1SequenceHeader*", "pStdSequenceHeader", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1SequenceHeader); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoDecodeAV1PictureInfoKHR(const VkVideoDecodeAV1PictureInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pStdPictureInfo, settings, "const StdVideoDecodeAV1PictureInfo*", "pStdPictureInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoDecodeAV1PictureInfo); + dump_separate_members(settings); + dump_single_array(object.referenceNameSlotIndices, VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR, settings, "int32_t[VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR]", "referenceNameSlotIndices", "int32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.frameHeaderOffset, settings, "uint32_t", "frameHeaderOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tileCount, settings, "uint32_t", "tileCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pTileOffsets, object.tileCount, settings, "const uint32_t*", "pTileOffsets", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(object.pTileSizes, object.tileCount, settings, "const uint32_t*", "pTileSizes", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoDecodeAV1DpbSlotInfoKHR(const VkVideoDecodeAV1DpbSlotInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pStdReferenceInfo, settings, "const StdVideoDecodeAV1ReferenceInfo*", "pStdReferenceInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoDecodeAV1ReferenceInfo); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR(const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.videoEncodeAV1, settings, "VkBool32", "videoEncodeAV1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeAV1CapabilitiesKHR(const VkVideoEncodeAV1CapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeAV1CapabilityFlagsKHR(object.flags, settings, "VkVideoEncodeAV1CapabilityFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoAV1Level(object.maxLevel, settings, "StdVideoAV1Level", "maxLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.codedPictureAlignment, settings, "VkExtent2D", "codedPictureAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.maxTiles, settings, "VkExtent2D", "maxTiles", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.minTileSize, settings, "VkExtent2D", "minTileSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.maxTileSize, settings, "VkExtent2D", "maxTileSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeAV1SuperblockSizeFlagsKHR(object.superblockSizes, settings, "VkVideoEncodeAV1SuperblockSizeFlagsKHR", "superblockSizes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxSingleReferenceCount, settings, "uint32_t", "maxSingleReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.singleReferenceNameMask, settings, "uint32_t", "singleReferenceNameMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxUnidirectionalCompoundReferenceCount, settings, "uint32_t", "maxUnidirectionalCompoundReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxUnidirectionalCompoundGroup1ReferenceCount, settings, "uint32_t", "maxUnidirectionalCompoundGroup1ReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.unidirectionalCompoundReferenceNameMask, settings, "uint32_t", "unidirectionalCompoundReferenceNameMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxBidirectionalCompoundReferenceCount, settings, "uint32_t", "maxBidirectionalCompoundReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxBidirectionalCompoundGroup1ReferenceCount, settings, "uint32_t", "maxBidirectionalCompoundGroup1ReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxBidirectionalCompoundGroup2ReferenceCount, settings, "uint32_t", "maxBidirectionalCompoundGroup2ReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bidirectionalCompoundReferenceNameMask, settings, "uint32_t", "bidirectionalCompoundReferenceNameMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxTemporalLayerCount, settings, "uint32_t", "maxTemporalLayerCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxSpatialLayerCount, settings, "uint32_t", "maxSpatialLayerCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxOperatingPoints, settings, "uint32_t", "maxOperatingPoints", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minQIndex, settings, "uint32_t", "minQIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxQIndex, settings, "uint32_t", "maxQIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.prefersGopRemainingFrames, settings, "VkBool32", "prefersGopRemainingFrames", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.requiresGopRemainingFrames, settings, "VkBool32", "requiresGopRemainingFrames", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeAV1StdFlagsKHR(object.stdSyntaxFlags, settings, "VkVideoEncodeAV1StdFlagsKHR", "stdSyntaxFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeAV1QIndexKHR(const VkVideoEncodeAV1QIndexKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.intraQIndex, settings, "uint32_t", "intraQIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.predictiveQIndex, settings, "uint32_t", "predictiveQIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bipredictiveQIndex, settings, "uint32_t", "bipredictiveQIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeAV1QualityLevelPropertiesKHR(const VkVideoEncodeAV1QualityLevelPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeAV1RateControlFlagsKHR(object.preferredRateControlFlags, settings, "VkVideoEncodeAV1RateControlFlagsKHR", "preferredRateControlFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.preferredGopFrameCount, settings, "uint32_t", "preferredGopFrameCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.preferredKeyFramePeriod, settings, "uint32_t", "preferredKeyFramePeriod", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.preferredConsecutiveBipredictiveFrameCount, settings, "uint32_t", "preferredConsecutiveBipredictiveFrameCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.preferredTemporalLayerCount, settings, "uint32_t", "preferredTemporalLayerCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeAV1QIndexKHR(object.preferredConstantQIndex, settings, "VkVideoEncodeAV1QIndexKHR", "preferredConstantQIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.preferredMaxSingleReferenceCount, settings, "uint32_t", "preferredMaxSingleReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.preferredSingleReferenceNameMask, settings, "uint32_t", "preferredSingleReferenceNameMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.preferredMaxUnidirectionalCompoundReferenceCount, settings, "uint32_t", "preferredMaxUnidirectionalCompoundReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.preferredMaxUnidirectionalCompoundGroup1ReferenceCount, settings, "uint32_t", "preferredMaxUnidirectionalCompoundGroup1ReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.preferredUnidirectionalCompoundReferenceNameMask, settings, "uint32_t", "preferredUnidirectionalCompoundReferenceNameMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.preferredMaxBidirectionalCompoundReferenceCount, settings, "uint32_t", "preferredMaxBidirectionalCompoundReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.preferredMaxBidirectionalCompoundGroup1ReferenceCount, settings, "uint32_t", "preferredMaxBidirectionalCompoundGroup1ReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.preferredMaxBidirectionalCompoundGroup2ReferenceCount, settings, "uint32_t", "preferredMaxBidirectionalCompoundGroup2ReferenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.preferredBidirectionalCompoundReferenceNameMask, settings, "uint32_t", "preferredBidirectionalCompoundReferenceNameMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeAV1SessionCreateInfoKHR(const VkVideoEncodeAV1SessionCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.useMaxLevel, settings, "VkBool32", "useMaxLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoAV1Level(object.maxLevel, settings, "StdVideoAV1Level", "maxLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeAV1SessionParametersCreateInfoKHR(const VkVideoEncodeAV1SessionParametersCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pStdSequenceHeader, settings, "const StdVideoAV1SequenceHeader*", "pStdSequenceHeader", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1SequenceHeader); + dump_separate_members(settings); + dump_pointer(object.pStdDecoderModelInfo, settings, "const StdVideoEncodeAV1DecoderModelInfo*", "pStdDecoderModelInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeAV1DecoderModelInfo); + dump_separate_members(settings); + dump_type(object.stdOperatingPointCount, settings, "uint32_t", "stdOperatingPointCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pStdOperatingPoints, object.stdOperatingPointCount, settings, "const StdVideoEncodeAV1OperatingPointInfo*", "pStdOperatingPoints", "const StdVideoEncodeAV1OperatingPointInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeAV1OperatingPointInfo); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeAV1PictureInfoKHR(const VkVideoEncodeAV1PictureInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeAV1PredictionModeKHR(object.predictionMode, settings, "VkVideoEncodeAV1PredictionModeKHR", "predictionMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeAV1RateControlGroupKHR(object.rateControlGroup, settings, "VkVideoEncodeAV1RateControlGroupKHR", "rateControlGroup", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.constantQIndex, settings, "uint32_t", "constantQIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pStdPictureInfo, settings, "const StdVideoEncodeAV1PictureInfo*", "pStdPictureInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeAV1PictureInfo); + dump_separate_members(settings); + dump_single_array(object.referenceNameSlotIndices, VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR, settings, "int32_t[VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR]", "referenceNameSlotIndices", "int32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.primaryReferenceCdfOnly, settings, "VkBool32", "primaryReferenceCdfOnly", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.generateObuExtensionHeader, settings, "VkBool32", "generateObuExtensionHeader", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeAV1DpbSlotInfoKHR(const VkVideoEncodeAV1DpbSlotInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pStdReferenceInfo, settings, "const StdVideoEncodeAV1ReferenceInfo*", "pStdReferenceInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoEncodeAV1ReferenceInfo); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeAV1ProfileInfoKHR(const VkVideoEncodeAV1ProfileInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoAV1Profile(object.stdProfile, settings, "StdVideoAV1Profile", "stdProfile", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeAV1FrameSizeKHR(const VkVideoEncodeAV1FrameSizeKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.intraFrameSize, settings, "uint32_t", "intraFrameSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.predictiveFrameSize, settings, "uint32_t", "predictiveFrameSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bipredictiveFrameSize, settings, "uint32_t", "bipredictiveFrameSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeAV1GopRemainingFrameInfoKHR(const VkVideoEncodeAV1GopRemainingFrameInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.useGopRemainingFrames, settings, "VkBool32", "useGopRemainingFrames", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.gopRemainingIntra, settings, "uint32_t", "gopRemainingIntra", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.gopRemainingPredictive, settings, "uint32_t", "gopRemainingPredictive", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.gopRemainingBipredictive, settings, "uint32_t", "gopRemainingBipredictive", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeAV1RateControlInfoKHR(const VkVideoEncodeAV1RateControlInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeAV1RateControlFlagsKHR(object.flags, settings, "VkVideoEncodeAV1RateControlFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.gopFrameCount, settings, "uint32_t", "gopFrameCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.keyFramePeriod, settings, "uint32_t", "keyFramePeriod", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.consecutiveBipredictiveFrameCount, settings, "uint32_t", "consecutiveBipredictiveFrameCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.temporalLayerCount, settings, "uint32_t", "temporalLayerCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeAV1RateControlLayerInfoKHR(const VkVideoEncodeAV1RateControlLayerInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.useMinQIndex, settings, "VkBool32", "useMinQIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeAV1QIndexKHR(object.minQIndex, settings, "VkVideoEncodeAV1QIndexKHR", "minQIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.useMaxQIndex, settings, "VkBool32", "useMaxQIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeAV1QIndexKHR(object.maxQIndex, settings, "VkVideoEncodeAV1QIndexKHR", "maxQIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.useMaxFrameSize, settings, "VkBool32", "useMaxFrameSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeAV1FrameSizeKHR(object.maxFrameSize, settings, "VkVideoEncodeAV1FrameSizeKHR", "maxFrameSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR(const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.videoDecodeVP9, settings, "VkBool32", "videoDecodeVP9", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoDecodeVP9ProfileInfoKHR(const VkVideoDecodeVP9ProfileInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoVP9Profile(object.stdProfile, settings, "StdVideoVP9Profile", "stdProfile", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoDecodeVP9CapabilitiesKHR(const VkVideoDecodeVP9CapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_StdVideoVP9Level(object.maxLevel, settings, "StdVideoVP9Level", "maxLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoDecodeVP9PictureInfoKHR(const VkVideoDecodeVP9PictureInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pStdPictureInfo, settings, "const StdVideoDecodeVP9PictureInfo*", "pStdPictureInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoDecodeVP9PictureInfo); + dump_separate_members(settings); + dump_single_array(object.referenceNameSlotIndices, VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR, settings, "int32_t[VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR]", "referenceNameSlotIndices", "int32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.uncompressedHeaderOffset, settings, "uint32_t", "uncompressedHeaderOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.compressedHeaderOffset, settings, "uint32_t", "compressedHeaderOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tilesOffset, settings, "uint32_t", "tilesOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceVideoMaintenance1FeaturesKHR(const VkPhysicalDeviceVideoMaintenance1FeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.videoMaintenance1, settings, "VkBool32", "videoMaintenance1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoInlineQueryInfoKHR(const VkVideoInlineQueryInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkQueryPool(object.queryPool, settings, "VkQueryPool", "queryPool", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.firstQuery, settings, "uint32_t", "firstQuery", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.queryCount, settings, "uint32_t", "queryCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR(const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.unifiedImageLayouts, settings, "VkBool32", "unifiedImageLayouts", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.unifiedImageLayoutsVideo, settings, "VkBool32", "unifiedImageLayoutsVideo", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAttachmentFeedbackLoopInfoEXT(const VkAttachmentFeedbackLoopInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.feedbackLoopEnable, settings, "VkBool32", "feedbackLoopEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCalibratedTimestampInfoKHR(const VkCalibratedTimestampInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkTimeDomainKHR(object.timeDomain, settings, "VkTimeDomainKHR", "timeDomain", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSetDescriptorBufferOffsetsInfoEXT(const VkSetDescriptorBufferOffsetsInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkShaderStageFlags(object.stageFlags, settings, "VkShaderStageFlags", "stageFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineLayout(object.layout, settings, "VkPipelineLayout", "layout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.firstSet, settings, "uint32_t", "firstSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.setCount, settings, "uint32_t", "setCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pBufferIndices, object.setCount, settings, "const uint32_t*", "pBufferIndices", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(object.pOffsets, object.setCount, settings, "const VkDeviceSize*", "pOffsets", "const VkDeviceSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBindDescriptorBufferEmbeddedSamplersInfoEXT(const VkBindDescriptorBufferEmbeddedSamplersInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkShaderStageFlags(object.stageFlags, settings, "VkShaderStageFlags", "stageFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineLayout(object.layout, settings, "VkPipelineLayout", "layout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.set, settings, "uint32_t", "set", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkStridedDeviceAddressRangeKHR(const VkStridedDeviceAddressRangeKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type_hex(object.address, settings, "VkDeviceAddress", "address", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.stride, settings, "VkDeviceSize", "stride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCopyMemoryIndirectCommandKHR(const VkCopyMemoryIndirectCommandKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type_hex(object.srcAddress, settings, "VkDeviceAddress", "srcAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type_hex(object.dstAddress, settings, "VkDeviceAddress", "dstAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCopyMemoryIndirectInfoKHR(const VkCopyMemoryIndirectInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAddressCopyFlagsKHR(object.srcCopyFlags, settings, "VkAddressCopyFlagsKHR", "srcCopyFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAddressCopyFlagsKHR(object.dstCopyFlags, settings, "VkAddressCopyFlagsKHR", "dstCopyFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.copyCount, settings, "uint32_t", "copyCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkStridedDeviceAddressRangeKHR(object.copyAddressRange, settings, "VkStridedDeviceAddressRangeKHR", "copyAddressRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCopyMemoryToImageIndirectCommandKHR(const VkCopyMemoryToImageIndirectCommandKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type_hex(object.srcAddress, settings, "VkDeviceAddress", "srcAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bufferRowLength, settings, "uint32_t", "bufferRowLength", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bufferImageHeight, settings, "uint32_t", "bufferImageHeight", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageSubresourceLayers(object.imageSubresource, settings, "VkImageSubresourceLayers", "imageSubresource", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkOffset3D(object.imageOffset, settings, "VkOffset3D", "imageOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent3D(object.imageExtent, settings, "VkExtent3D", "imageExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCopyMemoryToImageIndirectInfoKHR(const VkCopyMemoryToImageIndirectInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAddressCopyFlagsKHR(object.srcCopyFlags, settings, "VkAddressCopyFlagsKHR", "srcCopyFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.copyCount, settings, "uint32_t", "copyCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkStridedDeviceAddressRangeKHR(object.copyAddressRange, settings, "VkStridedDeviceAddressRangeKHR", "copyAddressRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImage(object.dstImage, settings, "VkImage", "dstImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(object.dstImageLayout, settings, "VkImageLayout", "dstImageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pImageSubresources, object.copyCount, settings, "const VkImageSubresourceLayers*", "pImageSubresources", "const VkImageSubresourceLayers", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkImageSubresourceLayers); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR(const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.indirectMemoryCopy, settings, "VkBool32", "indirectMemoryCopy", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.indirectMemoryToImageCopy, settings, "VkBool32", "indirectMemoryToImageCopy", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR(const VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkQueueFlags(object.supportedQueues, settings, "VkQueueFlags", "supportedQueues", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeIntraRefreshCapabilitiesKHR(const VkVideoEncodeIntraRefreshCapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeIntraRefreshModeFlagsKHR(object.intraRefreshModes, settings, "VkVideoEncodeIntraRefreshModeFlagsKHR", "intraRefreshModes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxIntraRefreshCycleDuration, settings, "uint32_t", "maxIntraRefreshCycleDuration", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxIntraRefreshActiveReferencePictures, settings, "uint32_t", "maxIntraRefreshActiveReferencePictures", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.partitionIndependentIntraRefreshRegions, settings, "VkBool32", "partitionIndependentIntraRefreshRegions", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.nonRectangularIntraRefreshRegions, settings, "VkBool32", "nonRectangularIntraRefreshRegions", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeSessionIntraRefreshCreateInfoKHR(const VkVideoEncodeSessionIntraRefreshCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeIntraRefreshModeFlagBitsKHR(object.intraRefreshMode, settings, "VkVideoEncodeIntraRefreshModeFlagBitsKHR", "intraRefreshMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeIntraRefreshInfoKHR(const VkVideoEncodeIntraRefreshInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.intraRefreshCycleDuration, settings, "uint32_t", "intraRefreshCycleDuration", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.intraRefreshIndex, settings, "uint32_t", "intraRefreshIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoReferenceIntraRefreshInfoKHR(const VkVideoReferenceIntraRefreshInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dirtyIntraRefreshRegions, settings, "uint32_t", "dirtyIntraRefreshRegions", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR(const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.videoEncodeIntraRefresh, settings, "VkBool32", "videoEncodeIntraRefresh", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeQuantizationMapCapabilitiesKHR(const VkVideoEncodeQuantizationMapCapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.maxQuantizationMapExtent, settings, "VkExtent2D", "maxQuantizationMapExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoFormatQuantizationMapPropertiesKHR(const VkVideoFormatQuantizationMapPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.quantizationMapTexelSize, settings, "VkExtent2D", "quantizationMapTexelSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeQuantizationMapInfoKHR(const VkVideoEncodeQuantizationMapInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageView(object.quantizationMap, settings, "VkImageView", "quantizationMap", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.quantizationMapExtent, settings, "VkExtent2D", "quantizationMapExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR(const VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.quantizationMapTexelSize, settings, "VkExtent2D", "quantizationMapTexelSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR(const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.videoEncodeQuantizationMap, settings, "VkBool32", "videoEncodeQuantizationMap", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeH264QuantizationMapCapabilitiesKHR(const VkVideoEncodeH264QuantizationMapCapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minQpDelta, settings, "int32_t", "minQpDelta", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxQpDelta, settings, "int32_t", "maxQpDelta", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeH265QuantizationMapCapabilitiesKHR(const VkVideoEncodeH265QuantizationMapCapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minQpDelta, settings, "int32_t", "minQpDelta", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxQpDelta, settings, "int32_t", "maxQpDelta", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoFormatH265QuantizationMapPropertiesKHR(const VkVideoFormatH265QuantizationMapPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeH265CtbSizeFlagsKHR(object.compatibleCtbSizes, settings, "VkVideoEncodeH265CtbSizeFlagsKHR", "compatibleCtbSizes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR(const VkVideoEncodeAV1QuantizationMapCapabilitiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minQIndexDelta, settings, "int32_t", "minQIndexDelta", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxQIndexDelta, settings, "int32_t", "maxQIndexDelta", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoFormatAV1QuantizationMapPropertiesKHR(const VkVideoFormatAV1QuantizationMapPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeAV1SuperblockSizeFlagsKHR(object.compatibleSuperblockSizes, settings, "VkVideoEncodeAV1SuperblockSizeFlagsKHR", "compatibleSuperblockSizes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR(const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderRelaxedExtendedInstruction, settings, "VkBool32", "shaderRelaxedExtendedInstruction", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceMaintenance7FeaturesKHR(const VkPhysicalDeviceMaintenance7FeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maintenance7, settings, "VkBool32", "maintenance7", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceMaintenance7PropertiesKHR(const VkPhysicalDeviceMaintenance7PropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.robustFragmentShadingRateAttachmentAccess, settings, "VkBool32", "robustFragmentShadingRateAttachmentAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.separateDepthStencilAttachmentAccess, settings, "VkBool32", "separateDepthStencilAttachmentAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDescriptorSetTotalUniformBuffersDynamic, settings, "uint32_t", "maxDescriptorSetTotalUniformBuffersDynamic", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDescriptorSetTotalStorageBuffersDynamic, settings, "uint32_t", "maxDescriptorSetTotalStorageBuffersDynamic", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDescriptorSetTotalBuffersDynamic, settings, "uint32_t", "maxDescriptorSetTotalBuffersDynamic", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDescriptorSetUpdateAfterBindTotalBuffersDynamic, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindTotalBuffersDynamic", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceLayeredApiPropertiesKHR(const VkPhysicalDeviceLayeredApiPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vendorID, settings, "uint32_t", "vendorID", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.deviceID, settings, "uint32_t", "deviceID", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPhysicalDeviceLayeredApiKHR(object.layeredAPI, settings, "VkPhysicalDeviceLayeredApiKHR", "layeredAPI", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_char(object.deviceName, settings, "char[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]", "deviceName", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceLayeredApiPropertiesListKHR(const VkPhysicalDeviceLayeredApiPropertiesListKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.layeredApiCount, settings, "uint32_t", "layeredApiCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pLayeredApis, object.layeredApiCount, settings, "VkPhysicalDeviceLayeredApiPropertiesKHR*", "pLayeredApis", "VkPhysicalDeviceLayeredApiPropertiesKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPhysicalDeviceLayeredApiPropertiesKHR); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR(const VkPhysicalDeviceLayeredApiVulkanPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPhysicalDeviceProperties2(object.properties, settings, "VkPhysicalDeviceProperties2", "properties", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMemoryBarrierAccessFlags3KHR(const VkMemoryBarrierAccessFlags3KHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccessFlags3KHR(object.srcAccessMask3, settings, "VkAccessFlags3KHR", "srcAccessMask3", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccessFlags3KHR(object.dstAccessMask3, settings, "VkAccessFlags3KHR", "dstAccessMask3", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceMaintenance8FeaturesKHR(const VkPhysicalDeviceMaintenance8FeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maintenance8, settings, "VkBool32", "maintenance8", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderFmaFeaturesKHR(const VkPhysicalDeviceShaderFmaFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderFmaFloat16, settings, "VkBool32", "shaderFmaFloat16", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderFmaFloat32, settings, "VkBool32", "shaderFmaFloat32", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderFmaFloat64, settings, "VkBool32", "shaderFmaFloat64", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceMaintenance9FeaturesKHR(const VkPhysicalDeviceMaintenance9FeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maintenance9, settings, "VkBool32", "maintenance9", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceMaintenance9PropertiesKHR(const VkPhysicalDeviceMaintenance9PropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.image2DViewOf3DSparse, settings, "VkBool32", "image2DViewOf3DSparse", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDefaultVertexAttributeValueKHR(object.defaultVertexAttributeValue, settings, "VkDefaultVertexAttributeValueKHR", "defaultVertexAttributeValue", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkQueueFamilyOwnershipTransferPropertiesKHR(const VkQueueFamilyOwnershipTransferPropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.optimalImageTransferToQueueFamilies, settings, "uint32_t", "optimalImageTransferToQueueFamilies", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceVideoMaintenance2FeaturesKHR(const VkPhysicalDeviceVideoMaintenance2FeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.videoMaintenance2, settings, "VkBool32", "videoMaintenance2", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoDecodeH264InlineSessionParametersInfoKHR(const VkVideoDecodeH264InlineSessionParametersInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pStdSPS, settings, "const StdVideoH264SequenceParameterSet*", "pStdSPS", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH264SequenceParameterSet); + dump_separate_members(settings); + dump_pointer(object.pStdPPS, settings, "const StdVideoH264PictureParameterSet*", "pStdPPS", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH264PictureParameterSet); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoDecodeH265InlineSessionParametersInfoKHR(const VkVideoDecodeH265InlineSessionParametersInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pStdVPS, settings, "const StdVideoH265VideoParameterSet*", "pStdVPS", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265VideoParameterSet); + dump_separate_members(settings); + dump_pointer(object.pStdSPS, settings, "const StdVideoH265SequenceParameterSet*", "pStdSPS", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265SequenceParameterSet); + dump_separate_members(settings); + dump_pointer(object.pStdPPS, settings, "const StdVideoH265PictureParameterSet*", "pStdPPS", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoH265PictureParameterSet); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoDecodeAV1InlineSessionParametersInfoKHR(const VkVideoDecodeAV1InlineSessionParametersInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pStdSequenceHeader, settings, "const StdVideoAV1SequenceHeader*", "pStdSequenceHeader", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_StdVideoAV1SequenceHeader); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR(const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.depthClampZeroOne, settings, "VkBool32", "depthClampZeroOne", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceRobustness2FeaturesKHR(const VkPhysicalDeviceRobustness2FeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.robustBufferAccess2, settings, "VkBool32", "robustBufferAccess2", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.robustImageAccess2, settings, "VkBool32", "robustImageAccess2", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.nullDescriptor, settings, "VkBool32", "nullDescriptor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceRobustness2PropertiesKHR(const VkPhysicalDeviceRobustness2PropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.robustStorageBufferAccessSizeAlignment, settings, "VkDeviceSize", "robustStorageBufferAccessSizeAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.robustUniformBufferAccessSizeAlignment, settings, "VkDeviceSize", "robustUniformBufferAccessSizeAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR(const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.presentModeFifoLatestReady, settings, "VkBool32", "presentModeFifoLatestReady", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceMaintenance10FeaturesKHR(const VkPhysicalDeviceMaintenance10FeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maintenance10, settings, "VkBool32", "maintenance10", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceMaintenance10PropertiesKHR(const VkPhysicalDeviceMaintenance10PropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.rgba4OpaqueBlackSwizzled, settings, "VkBool32", "rgba4OpaqueBlackSwizzled", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.resolveSrgbFormatAppliesTransferFunction, settings, "VkBool32", "resolveSrgbFormatAppliesTransferFunction", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.resolveSrgbFormatSupportsTransferFunctionControl, settings, "VkBool32", "resolveSrgbFormatSupportsTransferFunctionControl", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkRenderingEndInfoKHR(const VkRenderingEndInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkRenderingAttachmentFlagsInfoKHR(const VkRenderingAttachmentFlagsInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkRenderingAttachmentFlagsKHR(object.flags, settings, "VkRenderingAttachmentFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkResolveImageModeInfoKHR(const VkResolveImageModeInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkResolveImageFlagsKHR(object.flags, settings, "VkResolveImageFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkResolveModeFlagBits(object.resolveMode, settings, "VkResolveModeFlagBits", "resolveMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkResolveModeFlagBits(object.stencilResolveMode, settings, "VkResolveModeFlagBits", "stencilResolveMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDebugReportCallbackCreateInfoEXT(const VkDebugReportCallbackCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDebugReportFlagsEXT(object.flags, settings, "VkDebugReportFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_PFN_vkDebugReportCallbackEXT(object.pfnCallback, settings, "PFN_vkDebugReportCallbackEXT", "pfnCallback", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pUserData, settings, "void*", "pUserData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineRasterizationStateRasterizationOrderAMD(const VkPipelineRasterizationStateRasterizationOrderAMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkRasterizationOrderAMD(object.rasterizationOrder, settings, "VkRasterizationOrderAMD", "rasterizationOrder", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDebugMarkerObjectNameInfoEXT(const VkDebugMarkerObjectNameInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDebugReportObjectTypeEXT(object.objectType, settings, "VkDebugReportObjectTypeEXT", "objectType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.object, settings, "uint64_t", "object", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_char(object.pObjectName, settings, "const char*", "pObjectName", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDebugMarkerObjectTagInfoEXT(const VkDebugMarkerObjectTagInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDebugReportObjectTypeEXT(object.objectType, settings, "VkDebugReportObjectTypeEXT", "objectType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.object, settings, "uint64_t", "object", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tagName, settings, "uint64_t", "tagName", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tagSize, settings, "size_t", "tagSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pTag, settings, "const void*", "pTag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDebugMarkerMarkerInfoEXT(const VkDebugMarkerMarkerInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_char(object.pMarkerName, settings, "const char*", "pMarkerName", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.color, 4, settings, "float[4]", "color", "float", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDedicatedAllocationImageCreateInfoNV(const VkDedicatedAllocationImageCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dedicatedAllocation, settings, "VkBool32", "dedicatedAllocation", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDedicatedAllocationBufferCreateInfoNV(const VkDedicatedAllocationBufferCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dedicatedAllocation, settings, "VkBool32", "dedicatedAllocation", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDedicatedAllocationMemoryAllocateInfoNV(const VkDedicatedAllocationMemoryAllocateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImage(object.image, settings, "VkImage", "image", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBuffer(object.buffer, settings, "VkBuffer", "buffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceTransformFeedbackFeaturesEXT(const VkPhysicalDeviceTransformFeedbackFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.transformFeedback, settings, "VkBool32", "transformFeedback", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.geometryStreams, settings, "VkBool32", "geometryStreams", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceTransformFeedbackPropertiesEXT(const VkPhysicalDeviceTransformFeedbackPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxTransformFeedbackStreams, settings, "uint32_t", "maxTransformFeedbackStreams", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxTransformFeedbackBuffers, settings, "uint32_t", "maxTransformFeedbackBuffers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxTransformFeedbackBufferSize, settings, "VkDeviceSize", "maxTransformFeedbackBufferSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxTransformFeedbackStreamDataSize, settings, "uint32_t", "maxTransformFeedbackStreamDataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxTransformFeedbackBufferDataSize, settings, "uint32_t", "maxTransformFeedbackBufferDataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxTransformFeedbackBufferDataStride, settings, "uint32_t", "maxTransformFeedbackBufferDataStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.transformFeedbackQueries, settings, "VkBool32", "transformFeedbackQueries", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.transformFeedbackStreamsLinesTriangles, settings, "VkBool32", "transformFeedbackStreamsLinesTriangles", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.transformFeedbackRasterizationStreamSelect, settings, "VkBool32", "transformFeedbackRasterizationStreamSelect", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.transformFeedbackDraw, settings, "VkBool32", "transformFeedbackDraw", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineRasterizationStateStreamCreateInfoEXT(const VkPipelineRasterizationStateStreamCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineRasterizationStateStreamCreateFlagsEXT(object.flags, settings, "VkPipelineRasterizationStateStreamCreateFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.rasterizationStream, settings, "uint32_t", "rasterizationStream", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCuModuleCreateInfoNVX(const VkCuModuleCreateInfoNVX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dataSize, settings, "size_t", "dataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pData, settings, "const void*", "pData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCuModuleTexturingModeCreateInfoNVX(const VkCuModuleTexturingModeCreateInfoNVX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.use64bitTexturing, settings, "VkBool32", "use64bitTexturing", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCuFunctionCreateInfoNVX(const VkCuFunctionCreateInfoNVX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkCuModuleNVX(object.module, settings, "VkCuModuleNVX", "module", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_char(object.pName, settings, "const char*", "pName", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCuLaunchInfoNVX(const VkCuLaunchInfoNVX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkCuFunctionNVX(object.function, settings, "VkCuFunctionNVX", "function", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.gridDimX, settings, "uint32_t", "gridDimX", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.gridDimY, settings, "uint32_t", "gridDimY", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.gridDimZ, settings, "uint32_t", "gridDimZ", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.blockDimX, settings, "uint32_t", "blockDimX", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.blockDimY, settings, "uint32_t", "blockDimY", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.blockDimZ, settings, "uint32_t", "blockDimZ", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sharedMemBytes, settings, "uint32_t", "sharedMemBytes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.paramCount, settings, "size_t", "paramCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pParams, object.paramCount, settings, "const void* const *", "pParams", "const void*", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.extraCount, settings, "size_t", "extraCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pExtras, object.extraCount, settings, "const void* const *", "pExtras", "const void*", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImageViewHandleInfoNVX(const VkImageViewHandleInfoNVX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageView(object.imageView, settings, "VkImageView", "imageView", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDescriptorType(object.descriptorType, settings, "VkDescriptorType", "descriptorType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSampler(object.sampler, settings, "VkSampler", "sampler", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImageViewAddressPropertiesNVX(const VkImageViewAddressPropertiesNVX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type_hex(object.deviceAddress, settings, "VkDeviceAddress", "deviceAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkTextureLODGatherFormatPropertiesAMD(const VkTextureLODGatherFormatPropertiesAMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.supportsTextureGatherLODBiasAMD, settings, "VkBool32", "supportsTextureGatherLODBiasAMD", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkShaderResourceUsageAMD(const VkShaderResourceUsageAMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.numUsedVgprs, settings, "uint32_t", "numUsedVgprs", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.numUsedSgprs, settings, "uint32_t", "numUsedSgprs", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.ldsSizePerLocalWorkGroup, settings, "uint32_t", "ldsSizePerLocalWorkGroup", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.ldsUsageSizeInBytes, settings, "size_t", "ldsUsageSizeInBytes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.scratchMemUsageInBytes, settings, "size_t", "scratchMemUsageInBytes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkShaderStatisticsInfoAMD(const VkShaderStatisticsInfoAMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkShaderStageFlags(object.shaderStageMask, settings, "VkShaderStageFlags", "shaderStageMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkShaderResourceUsageAMD(object.resourceUsage, settings, "VkShaderResourceUsageAMD", "resourceUsage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.numPhysicalVgprs, settings, "uint32_t", "numPhysicalVgprs", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.numPhysicalSgprs, settings, "uint32_t", "numPhysicalSgprs", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.numAvailableVgprs, settings, "uint32_t", "numAvailableVgprs", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.numAvailableSgprs, settings, "uint32_t", "numAvailableSgprs", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.computeWorkGroupSize, 3, settings, "uint32_t[3]", "computeWorkGroupSize", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_end(settings, OutputConstruct::api_struct, indents); +} +#if defined(VK_USE_PLATFORM_GGP) +template +void dump_VkStreamDescriptorSurfaceCreateInfoGGP(const VkStreamDescriptorSurfaceCreateInfoGGP& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkStreamDescriptorSurfaceCreateFlagsGGP(object.flags, settings, "VkStreamDescriptorSurfaceCreateFlagsGGP", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.streamDescriptor, settings, "GgpStreamDescriptor", "streamDescriptor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#endif // VK_USE_PLATFORM_GGP +template +void dump_VkPhysicalDeviceCornerSampledImageFeaturesNV(const VkPhysicalDeviceCornerSampledImageFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.cornerSampledImage, settings, "VkBool32", "cornerSampledImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkExternalImageFormatPropertiesNV(const VkExternalImageFormatPropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkImageFormatProperties(object.imageFormatProperties, settings, "VkImageFormatProperties", "imageFormatProperties", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalMemoryFeatureFlagsNV(object.externalMemoryFeatures, settings, "VkExternalMemoryFeatureFlagsNV", "externalMemoryFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalMemoryHandleTypeFlagsNV(object.exportFromImportedHandleTypes, settings, "VkExternalMemoryHandleTypeFlagsNV", "exportFromImportedHandleTypes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalMemoryHandleTypeFlagsNV(object.compatibleHandleTypes, settings, "VkExternalMemoryHandleTypeFlagsNV", "compatibleHandleTypes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkExternalMemoryImageCreateInfoNV(const VkExternalMemoryImageCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalMemoryHandleTypeFlagsNV(object.handleTypes, settings, "VkExternalMemoryHandleTypeFlagsNV", "handleTypes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkExportMemoryAllocateInfoNV(const VkExportMemoryAllocateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalMemoryHandleTypeFlagsNV(object.handleTypes, settings, "VkExternalMemoryHandleTypeFlagsNV", "handleTypes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#if defined(VK_USE_PLATFORM_WIN32_KHR) +template +void dump_VkImportMemoryWin32HandleInfoNV(const VkImportMemoryWin32HandleInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalMemoryHandleTypeFlagsNV(object.handleType, settings, "VkExternalMemoryHandleTypeFlagsNV", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.handle, settings, "HANDLE", "handle", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkExportMemoryWin32HandleInfoNV(const VkExportMemoryWin32HandleInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pAttributes, settings, "const SECURITY_ATTRIBUTES*", "pAttributes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dwAccess, settings, "DWORD", "dwAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkWin32KeyedMutexAcquireReleaseInfoNV(const VkWin32KeyedMutexAcquireReleaseInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.acquireCount, settings, "uint32_t", "acquireCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pAcquireSyncs, object.acquireCount, settings, "const VkDeviceMemory*", "pAcquireSyncs", "const VkDeviceMemory", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDeviceMemory); + dump_separate_members(settings); + dump_pointer_array(object.pAcquireKeys, object.acquireCount, settings, "const uint64_t*", "pAcquireKeys", "const uint64_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(object.pAcquireTimeoutMilliseconds, object.acquireCount, settings, "const uint32_t*", "pAcquireTimeoutMilliseconds", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.releaseCount, settings, "uint32_t", "releaseCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pReleaseSyncs, object.releaseCount, settings, "const VkDeviceMemory*", "pReleaseSyncs", "const VkDeviceMemory", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDeviceMemory); + dump_separate_members(settings); + dump_pointer_array(object.pReleaseKeys, object.releaseCount, settings, "const uint64_t*", "pReleaseKeys", "const uint64_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#endif // VK_USE_PLATFORM_WIN32_KHR +template +void dump_VkValidationFlagsEXT(const VkValidationFlagsEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.disabledValidationCheckCount, settings, "uint32_t", "disabledValidationCheckCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pDisabledValidationChecks, object.disabledValidationCheckCount, settings, "const VkValidationCheckEXT*", "pDisabledValidationChecks", "const VkValidationCheckEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkValidationCheckEXT); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#if defined(VK_USE_PLATFORM_VI_NN) +template +void dump_VkViSurfaceCreateInfoNN(const VkViSurfaceCreateInfoNN& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkViSurfaceCreateFlagsNN(object.flags, settings, "VkViSurfaceCreateFlagsNN", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.window, settings, "void*", "window", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#endif // VK_USE_PLATFORM_VI_NN +template +void dump_VkImageViewASTCDecodeModeEXT(const VkImageViewASTCDecodeModeEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormat(object.decodeMode, settings, "VkFormat", "decodeMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceASTCDecodeFeaturesEXT(const VkPhysicalDeviceASTCDecodeFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.decodeModeSharedExponent, settings, "VkBool32", "decodeModeSharedExponent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkConditionalRenderingBeginInfoEXT(const VkConditionalRenderingBeginInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBuffer(object.buffer, settings, "VkBuffer", "buffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.offset, settings, "VkDeviceSize", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkConditionalRenderingFlagsEXT(object.flags, settings, "VkConditionalRenderingFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceConditionalRenderingFeaturesEXT(const VkPhysicalDeviceConditionalRenderingFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.conditionalRendering, settings, "VkBool32", "conditionalRendering", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.inheritedConditionalRendering, settings, "VkBool32", "inheritedConditionalRendering", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCommandBufferInheritanceConditionalRenderingInfoEXT(const VkCommandBufferInheritanceConditionalRenderingInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.conditionalRenderingEnable, settings, "VkBool32", "conditionalRenderingEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkViewportWScalingNV(const VkViewportWScalingNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.xcoeff, settings, "float", "xcoeff", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.ycoeff, settings, "float", "ycoeff", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineViewportWScalingStateCreateInfoNV(const VkPipelineViewportWScalingStateCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.viewportWScalingEnable, settings, "VkBool32", "viewportWScalingEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.viewportCount, settings, "uint32_t", "viewportCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pViewportWScalings, object.viewportCount, settings, "const VkViewportWScalingNV*", "pViewportWScalings", "const VkViewportWScalingNV", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkViewportWScalingNV); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSurfaceCapabilities2EXT(const VkSurfaceCapabilities2EXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minImageCount, settings, "uint32_t", "minImageCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxImageCount, settings, "uint32_t", "maxImageCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.currentExtent, settings, "VkExtent2D", "currentExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.minImageExtent, settings, "VkExtent2D", "minImageExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.maxImageExtent, settings, "VkExtent2D", "maxImageExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxImageArrayLayers, settings, "uint32_t", "maxImageArrayLayers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSurfaceTransformFlagsKHR(object.supportedTransforms, settings, "VkSurfaceTransformFlagsKHR", "supportedTransforms", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSurfaceTransformFlagBitsKHR(object.currentTransform, settings, "VkSurfaceTransformFlagBitsKHR", "currentTransform", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkCompositeAlphaFlagsKHR(object.supportedCompositeAlpha, settings, "VkCompositeAlphaFlagsKHR", "supportedCompositeAlpha", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageUsageFlags(object.supportedUsageFlags, settings, "VkImageUsageFlags", "supportedUsageFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSurfaceCounterFlagsEXT(object.supportedSurfaceCounters, settings, "VkSurfaceCounterFlagsEXT", "supportedSurfaceCounters", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDisplayPowerInfoEXT(const VkDisplayPowerInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDisplayPowerStateEXT(object.powerState, settings, "VkDisplayPowerStateEXT", "powerState", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDeviceEventInfoEXT(const VkDeviceEventInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceEventTypeEXT(object.deviceEvent, settings, "VkDeviceEventTypeEXT", "deviceEvent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDisplayEventInfoEXT(const VkDisplayEventInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDisplayEventTypeEXT(object.displayEvent, settings, "VkDisplayEventTypeEXT", "displayEvent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSwapchainCounterCreateInfoEXT(const VkSwapchainCounterCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSurfaceCounterFlagsEXT(object.surfaceCounters, settings, "VkSurfaceCounterFlagsEXT", "surfaceCounters", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkRefreshCycleDurationGOOGLE(const VkRefreshCycleDurationGOOGLE& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.refreshDuration, settings, "uint64_t", "refreshDuration", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPastPresentationTimingGOOGLE(const VkPastPresentationTimingGOOGLE& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.presentID, settings, "uint32_t", "presentID", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.desiredPresentTime, settings, "uint64_t", "desiredPresentTime", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.actualPresentTime, settings, "uint64_t", "actualPresentTime", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.earliestPresentTime, settings, "uint64_t", "earliestPresentTime", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.presentMargin, settings, "uint64_t", "presentMargin", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPresentTimeGOOGLE(const VkPresentTimeGOOGLE& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.presentID, settings, "uint32_t", "presentID", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.desiredPresentTime, settings, "uint64_t", "desiredPresentTime", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPresentTimesInfoGOOGLE(const VkPresentTimesInfoGOOGLE& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.swapchainCount, settings, "uint32_t", "swapchainCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pTimes, object.swapchainCount, settings, "const VkPresentTimeGOOGLE*", "pTimes", "const VkPresentTimeGOOGLE", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPresentTimeGOOGLE); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.perViewPositionAllComponents, settings, "VkBool32", "perViewPositionAllComponents", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMultiviewPerViewAttributesInfoNVX(const VkMultiviewPerViewAttributesInfoNVX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.perViewAttributes, settings, "VkBool32", "perViewAttributes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.perViewAttributesPositionXOnly, settings, "VkBool32", "perViewAttributesPositionXOnly", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkViewportSwizzleNV(const VkViewportSwizzleNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkViewportCoordinateSwizzleNV(object.x, settings, "VkViewportCoordinateSwizzleNV", "x", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkViewportCoordinateSwizzleNV(object.y, settings, "VkViewportCoordinateSwizzleNV", "y", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkViewportCoordinateSwizzleNV(object.z, settings, "VkViewportCoordinateSwizzleNV", "z", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkViewportCoordinateSwizzleNV(object.w, settings, "VkViewportCoordinateSwizzleNV", "w", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineViewportSwizzleStateCreateInfoNV(const VkPipelineViewportSwizzleStateCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineViewportSwizzleStateCreateFlagsNV(object.flags, settings, "VkPipelineViewportSwizzleStateCreateFlagsNV", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.viewportCount, settings, "uint32_t", "viewportCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pViewportSwizzles, object.viewportCount, settings, "const VkViewportSwizzleNV*", "pViewportSwizzles", "const VkViewportSwizzleNV", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkViewportSwizzleNV); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceDiscardRectanglePropertiesEXT(const VkPhysicalDeviceDiscardRectanglePropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDiscardRectangles, settings, "uint32_t", "maxDiscardRectangles", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineDiscardRectangleStateCreateInfoEXT(const VkPipelineDiscardRectangleStateCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineDiscardRectangleStateCreateFlagsEXT(object.flags, settings, "VkPipelineDiscardRectangleStateCreateFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDiscardRectangleModeEXT(object.discardRectangleMode, settings, "VkDiscardRectangleModeEXT", "discardRectangleMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.discardRectangleCount, settings, "uint32_t", "discardRectangleCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pDiscardRectangles, object.discardRectangleCount, settings, "const VkRect2D*", "pDiscardRectangles", "const VkRect2D", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkRect2D); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(const VkPhysicalDeviceConservativeRasterizationPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.primitiveOverestimationSize, settings, "float", "primitiveOverestimationSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxExtraPrimitiveOverestimationSize, settings, "float", "maxExtraPrimitiveOverestimationSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.extraPrimitiveOverestimationSizeGranularity, settings, "float", "extraPrimitiveOverestimationSizeGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.primitiveUnderestimation, settings, "VkBool32", "primitiveUnderestimation", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.conservativePointAndLineRasterization, settings, "VkBool32", "conservativePointAndLineRasterization", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.degenerateTrianglesRasterized, settings, "VkBool32", "degenerateTrianglesRasterized", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.degenerateLinesRasterized, settings, "VkBool32", "degenerateLinesRasterized", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.fullyCoveredFragmentShaderInputVariable, settings, "VkBool32", "fullyCoveredFragmentShaderInputVariable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.conservativeRasterizationPostDepthCoverage, settings, "VkBool32", "conservativeRasterizationPostDepthCoverage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineRasterizationConservativeStateCreateInfoEXT(const VkPipelineRasterizationConservativeStateCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineRasterizationConservativeStateCreateFlagsEXT(object.flags, settings, "VkPipelineRasterizationConservativeStateCreateFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkConservativeRasterizationModeEXT(object.conservativeRasterizationMode, settings, "VkConservativeRasterizationModeEXT", "conservativeRasterizationMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.extraPrimitiveOverestimationSize, settings, "float", "extraPrimitiveOverestimationSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceDepthClipEnableFeaturesEXT(const VkPhysicalDeviceDepthClipEnableFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.depthClipEnable, settings, "VkBool32", "depthClipEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineRasterizationDepthClipStateCreateInfoEXT(const VkPipelineRasterizationDepthClipStateCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineRasterizationDepthClipStateCreateFlagsEXT(object.flags, settings, "VkPipelineRasterizationDepthClipStateCreateFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.depthClipEnable, settings, "VkBool32", "depthClipEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkXYColorEXT(const VkXYColorEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.x, settings, "float", "x", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.y, settings, "float", "y", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkHdrMetadataEXT(const VkHdrMetadataEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkXYColorEXT(object.displayPrimaryRed, settings, "VkXYColorEXT", "displayPrimaryRed", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkXYColorEXT(object.displayPrimaryGreen, settings, "VkXYColorEXT", "displayPrimaryGreen", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkXYColorEXT(object.displayPrimaryBlue, settings, "VkXYColorEXT", "displayPrimaryBlue", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkXYColorEXT(object.whitePoint, settings, "VkXYColorEXT", "whitePoint", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxLuminance, settings, "float", "maxLuminance", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minLuminance, settings, "float", "minLuminance", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxContentLightLevel, settings, "float", "maxContentLightLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxFrameAverageLightLevel, settings, "float", "maxFrameAverageLightLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG(const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.relaxedLineRasterization, settings, "VkBool32", "relaxedLineRasterization", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#if defined(VK_USE_PLATFORM_IOS_MVK) +template +void dump_VkIOSSurfaceCreateInfoMVK(const VkIOSSurfaceCreateInfoMVK& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkIOSSurfaceCreateFlagsMVK(object.flags, settings, "VkIOSSurfaceCreateFlagsMVK", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pView, settings, "const void*", "pView", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#endif // VK_USE_PLATFORM_IOS_MVK +#if defined(VK_USE_PLATFORM_MACOS_MVK) +template +void dump_VkMacOSSurfaceCreateInfoMVK(const VkMacOSSurfaceCreateInfoMVK& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkMacOSSurfaceCreateFlagsMVK(object.flags, settings, "VkMacOSSurfaceCreateFlagsMVK", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pView, settings, "const void*", "pView", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#endif // VK_USE_PLATFORM_MACOS_MVK +template +void dump_VkDebugUtilsLabelEXT(const VkDebugUtilsLabelEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_char(object.pLabelName, settings, "const char*", "pLabelName", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.color, 4, settings, "float[4]", "color", "float", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDebugUtilsObjectNameInfoEXT(const VkDebugUtilsObjectNameInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkObjectType(object.objectType, settings, "VkObjectType", "objectType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_uint64_t_as_pointer(object.objectHandle, settings, "uint64_t", "objectHandle", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_char(object.pObjectName, settings, "const char*", "pObjectName", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDebugUtilsMessengerCallbackDataEXT(const VkDebugUtilsMessengerCallbackDataEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDebugUtilsMessengerCallbackDataFlagsEXT(object.flags, settings, "VkDebugUtilsMessengerCallbackDataFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_char(object.pMessageIdName, settings, "const char*", "pMessageIdName", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.messageIdNumber, settings, "int32_t", "messageIdNumber", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_char(object.pMessage, settings, "const char*", "pMessage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.queueLabelCount, settings, "uint32_t", "queueLabelCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pQueueLabels, object.queueLabelCount, settings, "const VkDebugUtilsLabelEXT*", "pQueueLabels", "const VkDebugUtilsLabelEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDebugUtilsLabelEXT); + dump_separate_members(settings); + dump_type(object.cmdBufLabelCount, settings, "uint32_t", "cmdBufLabelCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pCmdBufLabels, object.cmdBufLabelCount, settings, "const VkDebugUtilsLabelEXT*", "pCmdBufLabels", "const VkDebugUtilsLabelEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDebugUtilsLabelEXT); + dump_separate_members(settings); + dump_type(object.objectCount, settings, "uint32_t", "objectCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pObjects, object.objectCount, settings, "const VkDebugUtilsObjectNameInfoEXT*", "pObjects", "const VkDebugUtilsObjectNameInfoEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDebugUtilsObjectNameInfoEXT); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDebugUtilsMessengerCreateInfoEXT(const VkDebugUtilsMessengerCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDebugUtilsMessengerCreateFlagsEXT(object.flags, settings, "VkDebugUtilsMessengerCreateFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDebugUtilsMessageSeverityFlagsEXT(object.messageSeverity, settings, "VkDebugUtilsMessageSeverityFlagsEXT", "messageSeverity", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDebugUtilsMessageTypeFlagsEXT(object.messageType, settings, "VkDebugUtilsMessageTypeFlagsEXT", "messageType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_PFN_vkDebugUtilsMessengerCallbackEXT(object.pfnUserCallback, settings, "PFN_vkDebugUtilsMessengerCallbackEXT", "pfnUserCallback", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pUserData, settings, "void*", "pUserData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDebugUtilsObjectTagInfoEXT(const VkDebugUtilsObjectTagInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkObjectType(object.objectType, settings, "VkObjectType", "objectType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_uint64_t_as_pointer(object.objectHandle, settings, "uint64_t", "objectHandle", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tagName, settings, "uint64_t", "tagName", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tagSize, settings, "size_t", "tagSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pTag, settings, "const void*", "pTag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#if defined(VK_USE_PLATFORM_ANDROID_KHR) +template +void dump_VkAndroidHardwareBufferUsageANDROID(const VkAndroidHardwareBufferUsageANDROID& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.androidHardwareBufferUsage, settings, "uint64_t", "androidHardwareBufferUsage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAndroidHardwareBufferPropertiesANDROID(const VkAndroidHardwareBufferPropertiesANDROID& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.allocationSize, settings, "VkDeviceSize", "allocationSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.memoryTypeBits, settings, "uint32_t", "memoryTypeBits", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAndroidHardwareBufferFormatPropertiesANDROID(const VkAndroidHardwareBufferFormatPropertiesANDROID& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormat(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.externalFormat, settings, "uint64_t", "externalFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormatFeatureFlags(object.formatFeatures, settings, "VkFormatFeatureFlags", "formatFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkComponentMapping(object.samplerYcbcrConversionComponents, settings, "VkComponentMapping", "samplerYcbcrConversionComponents", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSamplerYcbcrModelConversion(object.suggestedYcbcrModel, settings, "VkSamplerYcbcrModelConversion", "suggestedYcbcrModel", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSamplerYcbcrRange(object.suggestedYcbcrRange, settings, "VkSamplerYcbcrRange", "suggestedYcbcrRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkChromaLocation(object.suggestedXChromaOffset, settings, "VkChromaLocation", "suggestedXChromaOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkChromaLocation(object.suggestedYChromaOffset, settings, "VkChromaLocation", "suggestedYChromaOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImportAndroidHardwareBufferInfoANDROID(const VkImportAndroidHardwareBufferInfoANDROID& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.buffer, settings, "struct AHardwareBuffer*", "buffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMemoryGetAndroidHardwareBufferInfoANDROID(const VkMemoryGetAndroidHardwareBufferInfoANDROID& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceMemory(object.memory, settings, "VkDeviceMemory", "memory", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkExternalFormatANDROID(const VkExternalFormatANDROID& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.externalFormat, settings, "uint64_t", "externalFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAndroidHardwareBufferFormatProperties2ANDROID(const VkAndroidHardwareBufferFormatProperties2ANDROID& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormat(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.externalFormat, settings, "uint64_t", "externalFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormatFeatureFlags2(object.formatFeatures, settings, "VkFormatFeatureFlags2", "formatFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkComponentMapping(object.samplerYcbcrConversionComponents, settings, "VkComponentMapping", "samplerYcbcrConversionComponents", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSamplerYcbcrModelConversion(object.suggestedYcbcrModel, settings, "VkSamplerYcbcrModelConversion", "suggestedYcbcrModel", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSamplerYcbcrRange(object.suggestedYcbcrRange, settings, "VkSamplerYcbcrRange", "suggestedYcbcrRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkChromaLocation(object.suggestedXChromaOffset, settings, "VkChromaLocation", "suggestedXChromaOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkChromaLocation(object.suggestedYChromaOffset, settings, "VkChromaLocation", "suggestedYChromaOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#endif // VK_USE_PLATFORM_ANDROID_KHR +#if defined(VK_ENABLE_BETA_EXTENSIONS) +template +void dump_VkPhysicalDeviceShaderEnqueueFeaturesAMDX(const VkPhysicalDeviceShaderEnqueueFeaturesAMDX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderEnqueue, settings, "VkBool32", "shaderEnqueue", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderMeshEnqueue, settings, "VkBool32", "shaderMeshEnqueue", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderEnqueuePropertiesAMDX(const VkPhysicalDeviceShaderEnqueuePropertiesAMDX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxExecutionGraphDepth, settings, "uint32_t", "maxExecutionGraphDepth", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxExecutionGraphShaderOutputNodes, settings, "uint32_t", "maxExecutionGraphShaderOutputNodes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxExecutionGraphShaderPayloadSize, settings, "uint32_t", "maxExecutionGraphShaderPayloadSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxExecutionGraphShaderPayloadCount, settings, "uint32_t", "maxExecutionGraphShaderPayloadCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.executionGraphDispatchAddressAlignment, settings, "uint32_t", "executionGraphDispatchAddressAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.maxExecutionGraphWorkgroupCount, 3, settings, "uint32_t[3]", "maxExecutionGraphWorkgroupCount", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.maxExecutionGraphWorkgroups, settings, "uint32_t", "maxExecutionGraphWorkgroups", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkExecutionGraphPipelineScratchSizeAMDX(const VkExecutionGraphPipelineScratchSizeAMDX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minSize, settings, "VkDeviceSize", "minSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxSize, settings, "VkDeviceSize", "maxSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sizeGranularity, settings, "VkDeviceSize", "sizeGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkExecutionGraphPipelineCreateInfoAMDX(const VkExecutionGraphPipelineCreateInfoAMDX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineCreateFlags(object.flags, settings, "VkPipelineCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.stageCount, settings, "uint32_t", "stageCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pStages, object.stageCount, settings, "const VkPipelineShaderStageCreateInfo*", "pStages", "const VkPipelineShaderStageCreateInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineShaderStageCreateInfo); + dump_separate_members(settings); + dump_pointer(object.pLibraryInfo, settings, "const VkPipelineLibraryCreateInfoKHR*", "pLibraryInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineLibraryCreateInfoKHR); + dump_separate_members(settings); + dump_VkPipelineLayout(object.layout, settings, "VkPipelineLayout", "layout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipeline(object.basePipelineHandle, settings, "VkPipeline", "basePipelineHandle", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.basePipelineIndex, settings, "int32_t", "basePipelineIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDeviceOrHostAddressConstAMDX(const VkDeviceOrHostAddressConstAMDX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_union, type_name, var_name, indents, address); + dump_type_hex(object.deviceAddress, settings, "VkDeviceAddress", "deviceAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.hostAddress, settings, "const void*", "hostAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDispatchGraphInfoAMDX(const VkDispatchGraphInfoAMDX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.nodeIndex, settings, "uint32_t", "nodeIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.payloadCount, settings, "uint32_t", "payloadCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceOrHostAddressConstAMDX(object.payloads, settings, "VkDeviceOrHostAddressConstAMDX", "payloads", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.payloadStride, settings, "uint64_t", "payloadStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDispatchGraphCountInfoAMDX(const VkDispatchGraphCountInfoAMDX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.count, settings, "uint32_t", "count", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceOrHostAddressConstAMDX(object.infos, settings, "VkDeviceOrHostAddressConstAMDX", "infos", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.stride, settings, "uint64_t", "stride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineShaderStageNodeCreateInfoAMDX(const VkPipelineShaderStageNodeCreateInfoAMDX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_char(object.pName, settings, "const char*", "pName", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.index, settings, "uint32_t", "index", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#endif // VK_ENABLE_BETA_EXTENSIONS +template +void dump_VkHostAddressRangeEXT(const VkHostAddressRangeEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.address, settings, "void*", "address", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.size, settings, "size_t", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkHostAddressRangeConstEXT(const VkHostAddressRangeConstEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.address, settings, "const void*", "address", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.size, settings, "size_t", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDeviceAddressRangeEXT(const VkDeviceAddressRangeEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type_hex(object.address, settings, "VkDeviceAddress", "address", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkTexelBufferDescriptorInfoEXT(const VkTexelBufferDescriptorInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormat(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceAddressRangeEXT(object.addressRange, settings, "VkDeviceAddressRangeEXT", "addressRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImageDescriptorInfoEXT(const VkImageDescriptorInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pView, settings, "const VkImageViewCreateInfo*", "pView", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkImageViewCreateInfo); + dump_separate_members(settings); + dump_VkImageLayout(object.layout, settings, "VkImageLayout", "layout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkTensorViewCreateInfoARM(const VkTensorViewCreateInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkTensorViewCreateFlagsARM(object.flags, settings, "VkTensorViewCreateFlagsARM", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkTensorARM(object.tensor, settings, "VkTensorARM", "tensor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormat(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkResourceDescriptorDataEXT(const VkResourceDescriptorDataEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_union, type_name, var_name, indents, address); + if (ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE || ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE || ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM || ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM || ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT) { + dump_pointer(object.pImage, settings, "const VkImageDescriptorInfoEXT*", "pImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkImageDescriptorInfoEXT); + } + dump_separate_members(settings); + if (ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER || ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER) { + dump_pointer(object.pTexelBuffer, settings, "const VkTexelBufferDescriptorInfoEXT*", "pTexelBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkTexelBufferDescriptorInfoEXT); + } + dump_separate_members(settings); + if (ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER || ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER || ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR || ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV || ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_NV) { + dump_pointer(object.pAddressRange, settings, "const VkDeviceAddressRangeEXT*", "pAddressRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDeviceAddressRangeEXT); + } + dump_separate_members(settings); + if (ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_TENSOR_ARM) { + dump_pointer(object.pTensorARM, settings, "const VkTensorViewCreateInfoARM*", "pTensorARM", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkTensorViewCreateInfoARM); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkResourceDescriptorInfoEXT(const VkResourceDescriptorInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + ApiDumpInstance::current().setDescriptorType(object.type); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDescriptorType(object.type, settings, "VkDescriptorType", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkResourceDescriptorDataEXT(object.data, settings, "VkResourceDescriptorDataEXT", "data", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBindHeapInfoEXT(const VkBindHeapInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceAddressRangeEXT(object.heapRange, settings, "VkDeviceAddressRangeEXT", "heapRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reservedRangeOffset, settings, "VkDeviceSize", "reservedRangeOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reservedRangeSize, settings, "VkDeviceSize", "reservedRangeSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPushDataInfoEXT(const VkPushDataInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.offset, settings, "uint32_t", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkHostAddressRangeConstEXT(object.data, settings, "VkHostAddressRangeConstEXT", "data", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDescriptorMappingSourceConstantOffsetEXT(const VkDescriptorMappingSourceConstantOffsetEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.heapOffset, settings, "uint32_t", "heapOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.heapArrayStride, settings, "uint32_t", "heapArrayStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pEmbeddedSampler, settings, "const VkSamplerCreateInfo*", "pEmbeddedSampler", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSamplerCreateInfo); + dump_separate_members(settings); + dump_type(object.samplerHeapOffset, settings, "uint32_t", "samplerHeapOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.samplerHeapArrayStride, settings, "uint32_t", "samplerHeapArrayStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDescriptorMappingSourcePushIndexEXT(const VkDescriptorMappingSourcePushIndexEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.heapOffset, settings, "uint32_t", "heapOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pushOffset, settings, "uint32_t", "pushOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.heapIndexStride, settings, "uint32_t", "heapIndexStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.heapArrayStride, settings, "uint32_t", "heapArrayStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pEmbeddedSampler, settings, "const VkSamplerCreateInfo*", "pEmbeddedSampler", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSamplerCreateInfo); + dump_separate_members(settings); + dump_type(object.useCombinedImageSamplerIndex, settings, "VkBool32", "useCombinedImageSamplerIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.samplerHeapOffset, settings, "uint32_t", "samplerHeapOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.samplerPushOffset, settings, "uint32_t", "samplerPushOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.samplerHeapIndexStride, settings, "uint32_t", "samplerHeapIndexStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.samplerHeapArrayStride, settings, "uint32_t", "samplerHeapArrayStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDescriptorMappingSourceIndirectIndexEXT(const VkDescriptorMappingSourceIndirectIndexEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.heapOffset, settings, "uint32_t", "heapOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pushOffset, settings, "uint32_t", "pushOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.addressOffset, settings, "uint32_t", "addressOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.heapIndexStride, settings, "uint32_t", "heapIndexStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.heapArrayStride, settings, "uint32_t", "heapArrayStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pEmbeddedSampler, settings, "const VkSamplerCreateInfo*", "pEmbeddedSampler", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSamplerCreateInfo); + dump_separate_members(settings); + dump_type(object.useCombinedImageSamplerIndex, settings, "VkBool32", "useCombinedImageSamplerIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.samplerHeapOffset, settings, "uint32_t", "samplerHeapOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.samplerPushOffset, settings, "uint32_t", "samplerPushOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.samplerAddressOffset, settings, "uint32_t", "samplerAddressOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.samplerHeapIndexStride, settings, "uint32_t", "samplerHeapIndexStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.samplerHeapArrayStride, settings, "uint32_t", "samplerHeapArrayStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDescriptorMappingSourceHeapDataEXT(const VkDescriptorMappingSourceHeapDataEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.heapOffset, settings, "uint32_t", "heapOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pushOffset, settings, "uint32_t", "pushOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDescriptorMappingSourceIndirectAddressEXT(const VkDescriptorMappingSourceIndirectAddressEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.pushOffset, settings, "uint32_t", "pushOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.addressOffset, settings, "uint32_t", "addressOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDescriptorMappingSourceShaderRecordIndexEXT(const VkDescriptorMappingSourceShaderRecordIndexEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.heapOffset, settings, "uint32_t", "heapOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderRecordOffset, settings, "uint32_t", "shaderRecordOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.heapIndexStride, settings, "uint32_t", "heapIndexStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.heapArrayStride, settings, "uint32_t", "heapArrayStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pEmbeddedSampler, settings, "const VkSamplerCreateInfo*", "pEmbeddedSampler", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSamplerCreateInfo); + dump_separate_members(settings); + dump_type(object.useCombinedImageSamplerIndex, settings, "VkBool32", "useCombinedImageSamplerIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.samplerHeapOffset, settings, "uint32_t", "samplerHeapOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.samplerShaderRecordOffset, settings, "uint32_t", "samplerShaderRecordOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.samplerHeapIndexStride, settings, "uint32_t", "samplerHeapIndexStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.samplerHeapArrayStride, settings, "uint32_t", "samplerHeapArrayStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDescriptorMappingSourceIndirectIndexArrayEXT(const VkDescriptorMappingSourceIndirectIndexArrayEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.heapOffset, settings, "uint32_t", "heapOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pushOffset, settings, "uint32_t", "pushOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.addressOffset, settings, "uint32_t", "addressOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.heapIndexStride, settings, "uint32_t", "heapIndexStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pEmbeddedSampler, settings, "const VkSamplerCreateInfo*", "pEmbeddedSampler", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSamplerCreateInfo); + dump_separate_members(settings); + dump_type(object.useCombinedImageSamplerIndex, settings, "VkBool32", "useCombinedImageSamplerIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.samplerHeapOffset, settings, "uint32_t", "samplerHeapOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.samplerPushOffset, settings, "uint32_t", "samplerPushOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.samplerAddressOffset, settings, "uint32_t", "samplerAddressOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.samplerHeapIndexStride, settings, "uint32_t", "samplerHeapIndexStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDescriptorMappingSourceDataEXT(const VkDescriptorMappingSourceDataEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_union, type_name, var_name, indents, address); + if (ApiDumpInstance::current().getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_CONSTANT_OFFSET_EXT) { + dump_VkDescriptorMappingSourceConstantOffsetEXT(object.constantOffset, settings, "VkDescriptorMappingSourceConstantOffsetEXT", "constantOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + } + dump_separate_members(settings); + if (ApiDumpInstance::current().getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_PUSH_INDEX_EXT) { + dump_VkDescriptorMappingSourcePushIndexEXT(object.pushIndex, settings, "VkDescriptorMappingSourcePushIndexEXT", "pushIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + } + dump_separate_members(settings); + if (ApiDumpInstance::current().getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_INDIRECT_INDEX_EXT) { + dump_VkDescriptorMappingSourceIndirectIndexEXT(object.indirectIndex, settings, "VkDescriptorMappingSourceIndirectIndexEXT", "indirectIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + } + dump_separate_members(settings); + if (ApiDumpInstance::current().getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_INDIRECT_INDEX_ARRAY_EXT) { + dump_VkDescriptorMappingSourceIndirectIndexArrayEXT(object.indirectIndexArray, settings, "VkDescriptorMappingSourceIndirectIndexArrayEXT", "indirectIndexArray", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + } + dump_separate_members(settings); + if (ApiDumpInstance::current().getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_RESOURCE_HEAP_DATA_EXT) { + dump_VkDescriptorMappingSourceHeapDataEXT(object.heapData, settings, "VkDescriptorMappingSourceHeapDataEXT", "heapData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + } + dump_separate_members(settings); + if (ApiDumpInstance::current().getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_DATA_EXT) { + dump_type(object.pushDataOffset, settings, "uint32_t", "pushDataOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + } + dump_separate_members(settings); + if (ApiDumpInstance::current().getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_ADDRESS_EXT) { + dump_type(object.pushAddressOffset, settings, "uint32_t", "pushAddressOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + } + dump_separate_members(settings); + if (ApiDumpInstance::current().getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_INDIRECT_ADDRESS_EXT) { + dump_VkDescriptorMappingSourceIndirectAddressEXT(object.indirectAddress, settings, "VkDescriptorMappingSourceIndirectAddressEXT", "indirectAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + } + dump_separate_members(settings); + if (ApiDumpInstance::current().getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_SHADER_RECORD_INDEX_EXT) { + dump_VkDescriptorMappingSourceShaderRecordIndexEXT(object.shaderRecordIndex, settings, "VkDescriptorMappingSourceShaderRecordIndexEXT", "shaderRecordIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + } + dump_separate_members(settings); + if (ApiDumpInstance::current().getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_SHADER_RECORD_DATA_EXT) { + dump_type(object.shaderRecordDataOffset, settings, "uint32_t", "shaderRecordDataOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + } + dump_separate_members(settings); + if (ApiDumpInstance::current().getDescriptorMappingSource() == VK_DESCRIPTOR_MAPPING_SOURCE_SHADER_RECORD_ADDRESS_EXT) { + dump_type(object.shaderRecordAddressOffset, settings, "uint32_t", "shaderRecordAddressOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDescriptorSetAndBindingMappingEXT(const VkDescriptorSetAndBindingMappingEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + ApiDumpInstance::current().setDescriptorMappingSource(object.source); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorSet, settings, "uint32_t", "descriptorSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.firstBinding, settings, "uint32_t", "firstBinding", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bindingCount, settings, "uint32_t", "bindingCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSpirvResourceTypeFlagsEXT(object.resourceMask, settings, "VkSpirvResourceTypeFlagsEXT", "resourceMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDescriptorMappingSourceEXT(object.source, settings, "VkDescriptorMappingSourceEXT", "source", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDescriptorMappingSourceDataEXT(object.sourceData, settings, "VkDescriptorMappingSourceDataEXT", "sourceData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkShaderDescriptorSetAndBindingMappingInfoEXT(const VkShaderDescriptorSetAndBindingMappingInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.mappingCount, settings, "uint32_t", "mappingCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pMappings, object.mappingCount, settings, "const VkDescriptorSetAndBindingMappingEXT*", "pMappings", "const VkDescriptorSetAndBindingMappingEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorSetAndBindingMappingEXT); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkOpaqueCaptureDataCreateInfoEXT(const VkOpaqueCaptureDataCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pData, settings, "const VkHostAddressRangeConstEXT*", "pData", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkHostAddressRangeConstEXT); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceDescriptorHeapFeaturesEXT(const VkPhysicalDeviceDescriptorHeapFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorHeap, settings, "VkBool32", "descriptorHeap", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorHeapCaptureReplay, settings, "VkBool32", "descriptorHeapCaptureReplay", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceDescriptorHeapPropertiesEXT(const VkPhysicalDeviceDescriptorHeapPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.samplerHeapAlignment, settings, "VkDeviceSize", "samplerHeapAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.resourceHeapAlignment, settings, "VkDeviceSize", "resourceHeapAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxSamplerHeapSize, settings, "VkDeviceSize", "maxSamplerHeapSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxResourceHeapSize, settings, "VkDeviceSize", "maxResourceHeapSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minSamplerHeapReservedRange, settings, "VkDeviceSize", "minSamplerHeapReservedRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minSamplerHeapReservedRangeWithEmbedded, settings, "VkDeviceSize", "minSamplerHeapReservedRangeWithEmbedded", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minResourceHeapReservedRange, settings, "VkDeviceSize", "minResourceHeapReservedRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.samplerDescriptorSize, settings, "VkDeviceSize", "samplerDescriptorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.imageDescriptorSize, settings, "VkDeviceSize", "imageDescriptorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bufferDescriptorSize, settings, "VkDeviceSize", "bufferDescriptorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.samplerDescriptorAlignment, settings, "VkDeviceSize", "samplerDescriptorAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.imageDescriptorAlignment, settings, "VkDeviceSize", "imageDescriptorAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bufferDescriptorAlignment, settings, "VkDeviceSize", "bufferDescriptorAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPushDataSize, settings, "VkDeviceSize", "maxPushDataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.imageCaptureReplayOpaqueDataSize, settings, "size_t", "imageCaptureReplayOpaqueDataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDescriptorHeapEmbeddedSamplers, settings, "uint32_t", "maxDescriptorHeapEmbeddedSamplers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.samplerYcbcrConversionCount, settings, "uint32_t", "samplerYcbcrConversionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sparseDescriptorHeaps, settings, "VkBool32", "sparseDescriptorHeaps", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.protectedDescriptorHeaps, settings, "VkBool32", "protectedDescriptorHeaps", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCommandBufferInheritanceDescriptorHeapInfoEXT(const VkCommandBufferInheritanceDescriptorHeapInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pSamplerHeapBindInfo, settings, "const VkBindHeapInfoEXT*", "pSamplerHeapBindInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkBindHeapInfoEXT); + dump_separate_members(settings); + dump_pointer(object.pResourceHeapBindInfo, settings, "const VkBindHeapInfoEXT*", "pResourceHeapBindInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkBindHeapInfoEXT); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSamplerCustomBorderColorIndexCreateInfoEXT(const VkSamplerCustomBorderColorIndexCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.index, settings, "uint32_t", "index", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSamplerCustomBorderColorCreateInfoEXT(const VkSamplerCustomBorderColorCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkClearColorValue(object.customBorderColor, settings, "VkClearColorValue", "customBorderColor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormat(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkIndirectCommandsLayoutPushDataTokenNV(const VkIndirectCommandsLayoutPushDataTokenNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pushDataOffset, settings, "uint32_t", "pushDataOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pushDataSize, settings, "uint32_t", "pushDataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSubsampledImageFormatPropertiesEXT(const VkSubsampledImageFormatPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.subsampledImageDescriptorCount, settings, "uint32_t", "subsampledImageDescriptorCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceDescriptorHeapTensorPropertiesARM(const VkPhysicalDeviceDescriptorHeapTensorPropertiesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tensorDescriptorSize, settings, "VkDeviceSize", "tensorDescriptorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tensorDescriptorAlignment, settings, "VkDeviceSize", "tensorDescriptorAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tensorCaptureReplayOpaqueDataSize, settings, "size_t", "tensorCaptureReplayOpaqueDataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAttachmentSampleCountInfoAMD(const VkAttachmentSampleCountInfoAMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.colorAttachmentCount, settings, "uint32_t", "colorAttachmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pColorAttachmentSamples, object.colorAttachmentCount, settings, "const VkSampleCountFlagBits*", "pColorAttachmentSamples", "const VkSampleCountFlagBits", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSampleCountFlagBits); + dump_separate_members(settings); + dump_VkSampleCountFlagBits(object.depthStencilAttachmentSamples, settings, "VkSampleCountFlagBits", "depthStencilAttachmentSamples", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSampleLocationEXT(const VkSampleLocationEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.x, settings, "float", "x", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.y, settings, "float", "y", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSampleLocationsInfoEXT(const VkSampleLocationsInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSampleCountFlagBits(object.sampleLocationsPerPixel, settings, "VkSampleCountFlagBits", "sampleLocationsPerPixel", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.sampleLocationGridSize, settings, "VkExtent2D", "sampleLocationGridSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sampleLocationsCount, settings, "uint32_t", "sampleLocationsCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pSampleLocations, object.sampleLocationsCount, settings, "const VkSampleLocationEXT*", "pSampleLocations", "const VkSampleLocationEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSampleLocationEXT); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAttachmentSampleLocationsEXT(const VkAttachmentSampleLocationsEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.attachmentIndex, settings, "uint32_t", "attachmentIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSampleLocationsInfoEXT(object.sampleLocationsInfo, settings, "VkSampleLocationsInfoEXT", "sampleLocationsInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSubpassSampleLocationsEXT(const VkSubpassSampleLocationsEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.subpassIndex, settings, "uint32_t", "subpassIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSampleLocationsInfoEXT(object.sampleLocationsInfo, settings, "VkSampleLocationsInfoEXT", "sampleLocationsInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkRenderPassSampleLocationsBeginInfoEXT(const VkRenderPassSampleLocationsBeginInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.attachmentInitialSampleLocationsCount, settings, "uint32_t", "attachmentInitialSampleLocationsCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pAttachmentInitialSampleLocations, object.attachmentInitialSampleLocationsCount, settings, "const VkAttachmentSampleLocationsEXT*", "pAttachmentInitialSampleLocations", "const VkAttachmentSampleLocationsEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkAttachmentSampleLocationsEXT); + dump_separate_members(settings); + dump_type(object.postSubpassSampleLocationsCount, settings, "uint32_t", "postSubpassSampleLocationsCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pPostSubpassSampleLocations, object.postSubpassSampleLocationsCount, settings, "const VkSubpassSampleLocationsEXT*", "pPostSubpassSampleLocations", "const VkSubpassSampleLocationsEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSubpassSampleLocationsEXT); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineSampleLocationsStateCreateInfoEXT(const VkPipelineSampleLocationsStateCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sampleLocationsEnable, settings, "VkBool32", "sampleLocationsEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSampleLocationsInfoEXT(object.sampleLocationsInfo, settings, "VkSampleLocationsInfoEXT", "sampleLocationsInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceSampleLocationsPropertiesEXT(const VkPhysicalDeviceSampleLocationsPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSampleCountFlags(object.sampleLocationSampleCounts, settings, "VkSampleCountFlags", "sampleLocationSampleCounts", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.maxSampleLocationGridSize, settings, "VkExtent2D", "maxSampleLocationGridSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.sampleLocationCoordinateRange, 2, settings, "float[2]", "sampleLocationCoordinateRange", "float", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.sampleLocationSubPixelBits, settings, "uint32_t", "sampleLocationSubPixelBits", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.variableSampleLocations, settings, "VkBool32", "variableSampleLocations", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMultisamplePropertiesEXT(const VkMultisamplePropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.maxSampleLocationGridSize, settings, "VkExtent2D", "maxSampleLocationGridSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.advancedBlendCoherentOperations, settings, "VkBool32", "advancedBlendCoherentOperations", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.advancedBlendMaxColorAttachments, settings, "uint32_t", "advancedBlendMaxColorAttachments", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.advancedBlendIndependentBlend, settings, "VkBool32", "advancedBlendIndependentBlend", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.advancedBlendNonPremultipliedSrcColor, settings, "VkBool32", "advancedBlendNonPremultipliedSrcColor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.advancedBlendNonPremultipliedDstColor, settings, "VkBool32", "advancedBlendNonPremultipliedDstColor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.advancedBlendCorrelatedOverlap, settings, "VkBool32", "advancedBlendCorrelatedOverlap", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.advancedBlendAllOperations, settings, "VkBool32", "advancedBlendAllOperations", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineColorBlendAdvancedStateCreateInfoEXT(const VkPipelineColorBlendAdvancedStateCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.srcPremultiplied, settings, "VkBool32", "srcPremultiplied", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dstPremultiplied, settings, "VkBool32", "dstPremultiplied", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBlendOverlapEXT(object.blendOverlap, settings, "VkBlendOverlapEXT", "blendOverlap", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineCoverageToColorStateCreateInfoNV(const VkPipelineCoverageToColorStateCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineCoverageToColorStateCreateFlagsNV(object.flags, settings, "VkPipelineCoverageToColorStateCreateFlagsNV", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.coverageToColorEnable, settings, "VkBool32", "coverageToColorEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.coverageToColorLocation, settings, "uint32_t", "coverageToColorLocation", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineCoverageModulationStateCreateInfoNV(const VkPipelineCoverageModulationStateCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineCoverageModulationStateCreateFlagsNV(object.flags, settings, "VkPipelineCoverageModulationStateCreateFlagsNV", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkCoverageModulationModeNV(object.coverageModulationMode, settings, "VkCoverageModulationModeNV", "coverageModulationMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.coverageModulationTableEnable, settings, "VkBool32", "coverageModulationTableEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.coverageModulationTableCount, settings, "uint32_t", "coverageModulationTableCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pCoverageModulationTable, object.coverageModulationTableCount, settings, "const float*", "pCoverageModulationTable", "const float", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderSMCount, settings, "uint32_t", "shaderSMCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderWarpsPerSM, settings, "uint32_t", "shaderWarpsPerSM", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderSMBuiltins, settings, "VkBool32", "shaderSMBuiltins", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDrmFormatModifierPropertiesEXT(const VkDrmFormatModifierPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.drmFormatModifier, settings, "uint64_t", "drmFormatModifier", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.drmFormatModifierPlaneCount, settings, "uint32_t", "drmFormatModifierPlaneCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormatFeatureFlags(object.drmFormatModifierTilingFeatures, settings, "VkFormatFeatureFlags", "drmFormatModifierTilingFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDrmFormatModifierPropertiesListEXT(const VkDrmFormatModifierPropertiesListEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.drmFormatModifierCount, settings, "uint32_t", "drmFormatModifierCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pDrmFormatModifierProperties, object.drmFormatModifierCount, settings, "VkDrmFormatModifierPropertiesEXT*", "pDrmFormatModifierProperties", "VkDrmFormatModifierPropertiesEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDrmFormatModifierPropertiesEXT); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.drmFormatModifier, settings, "uint64_t", "drmFormatModifier", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSharingMode(object.sharingMode, settings, "VkSharingMode", "sharingMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.queueFamilyIndexCount, settings, "uint32_t", "queueFamilyIndexCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pQueueFamilyIndices, object.queueFamilyIndexCount, settings, "const uint32_t*", "pQueueFamilyIndices", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImageDrmFormatModifierListCreateInfoEXT(const VkImageDrmFormatModifierListCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.drmFormatModifierCount, settings, "uint32_t", "drmFormatModifierCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pDrmFormatModifiers, object.drmFormatModifierCount, settings, "const uint64_t*", "pDrmFormatModifiers", "const uint64_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImageDrmFormatModifierExplicitCreateInfoEXT(const VkImageDrmFormatModifierExplicitCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.drmFormatModifier, settings, "uint64_t", "drmFormatModifier", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.drmFormatModifierPlaneCount, settings, "uint32_t", "drmFormatModifierPlaneCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pPlaneLayouts, object.drmFormatModifierPlaneCount, settings, "const VkSubresourceLayout*", "pPlaneLayouts", "const VkSubresourceLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSubresourceLayout); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImageDrmFormatModifierPropertiesEXT(const VkImageDrmFormatModifierPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.drmFormatModifier, settings, "uint64_t", "drmFormatModifier", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDrmFormatModifierProperties2EXT(const VkDrmFormatModifierProperties2EXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.drmFormatModifier, settings, "uint64_t", "drmFormatModifier", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.drmFormatModifierPlaneCount, settings, "uint32_t", "drmFormatModifierPlaneCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormatFeatureFlags2(object.drmFormatModifierTilingFeatures, settings, "VkFormatFeatureFlags2", "drmFormatModifierTilingFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDrmFormatModifierPropertiesList2EXT(const VkDrmFormatModifierPropertiesList2EXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.drmFormatModifierCount, settings, "uint32_t", "drmFormatModifierCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pDrmFormatModifierProperties, object.drmFormatModifierCount, settings, "VkDrmFormatModifierProperties2EXT*", "pDrmFormatModifierProperties", "VkDrmFormatModifierProperties2EXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDrmFormatModifierProperties2EXT); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkValidationCacheCreateInfoEXT(const VkValidationCacheCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkValidationCacheCreateFlagsEXT(object.flags, settings, "VkValidationCacheCreateFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.initialDataSize, settings, "size_t", "initialDataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pInitialData, settings, "const void*", "pInitialData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkShaderModuleValidationCacheCreateInfoEXT(const VkShaderModuleValidationCacheCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkValidationCacheEXT(object.validationCache, settings, "VkValidationCacheEXT", "validationCache", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkShadingRatePaletteNV(const VkShadingRatePaletteNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.shadingRatePaletteEntryCount, settings, "uint32_t", "shadingRatePaletteEntryCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pShadingRatePaletteEntries, object.shadingRatePaletteEntryCount, settings, "const VkShadingRatePaletteEntryNV*", "pShadingRatePaletteEntries", "const VkShadingRatePaletteEntryNV", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkShadingRatePaletteEntryNV); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineViewportShadingRateImageStateCreateInfoNV(const VkPipelineViewportShadingRateImageStateCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shadingRateImageEnable, settings, "VkBool32", "shadingRateImageEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.viewportCount, settings, "uint32_t", "viewportCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pShadingRatePalettes, object.viewportCount, settings, "const VkShadingRatePaletteNV*", "pShadingRatePalettes", "const VkShadingRatePaletteNV", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkShadingRatePaletteNV); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShadingRateImageFeaturesNV(const VkPhysicalDeviceShadingRateImageFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shadingRateImage, settings, "VkBool32", "shadingRateImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shadingRateCoarseSampleOrder, settings, "VkBool32", "shadingRateCoarseSampleOrder", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShadingRateImagePropertiesNV(const VkPhysicalDeviceShadingRateImagePropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.shadingRateTexelSize, settings, "VkExtent2D", "shadingRateTexelSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shadingRatePaletteSize, settings, "uint32_t", "shadingRatePaletteSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shadingRateMaxCoarseSamples, settings, "uint32_t", "shadingRateMaxCoarseSamples", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCoarseSampleLocationNV(const VkCoarseSampleLocationNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.pixelX, settings, "uint32_t", "pixelX", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pixelY, settings, "uint32_t", "pixelY", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sample, settings, "uint32_t", "sample", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCoarseSampleOrderCustomNV(const VkCoarseSampleOrderCustomNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkShadingRatePaletteEntryNV(object.shadingRate, settings, "VkShadingRatePaletteEntryNV", "shadingRate", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sampleCount, settings, "uint32_t", "sampleCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sampleLocationCount, settings, "uint32_t", "sampleLocationCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pSampleLocations, object.sampleLocationCount, settings, "const VkCoarseSampleLocationNV*", "pSampleLocations", "const VkCoarseSampleLocationNV", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkCoarseSampleLocationNV); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkCoarseSampleOrderTypeNV(object.sampleOrderType, settings, "VkCoarseSampleOrderTypeNV", "sampleOrderType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.customSampleOrderCount, settings, "uint32_t", "customSampleOrderCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pCustomSampleOrders, object.customSampleOrderCount, settings, "const VkCoarseSampleOrderCustomNV*", "pCustomSampleOrders", "const VkCoarseSampleOrderCustomNV", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkCoarseSampleOrderCustomNV); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkRayTracingShaderGroupCreateInfoNV(const VkRayTracingShaderGroupCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkRayTracingShaderGroupTypeKHR(object.type, settings, "VkRayTracingShaderGroupTypeKHR", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.generalShader, settings, "uint32_t", "generalShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.closestHitShader, settings, "uint32_t", "closestHitShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.anyHitShader, settings, "uint32_t", "anyHitShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.intersectionShader, settings, "uint32_t", "intersectionShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkRayTracingPipelineCreateInfoNV(const VkRayTracingPipelineCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineCreateFlags(object.flags, settings, "VkPipelineCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.stageCount, settings, "uint32_t", "stageCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pStages, object.stageCount, settings, "const VkPipelineShaderStageCreateInfo*", "pStages", "const VkPipelineShaderStageCreateInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineShaderStageCreateInfo); + dump_separate_members(settings); + dump_type(object.groupCount, settings, "uint32_t", "groupCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pGroups, object.groupCount, settings, "const VkRayTracingShaderGroupCreateInfoNV*", "pGroups", "const VkRayTracingShaderGroupCreateInfoNV", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkRayTracingShaderGroupCreateInfoNV); + dump_separate_members(settings); + dump_type(object.maxRecursionDepth, settings, "uint32_t", "maxRecursionDepth", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineLayout(object.layout, settings, "VkPipelineLayout", "layout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipeline(object.basePipelineHandle, settings, "VkPipeline", "basePipelineHandle", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.basePipelineIndex, settings, "int32_t", "basePipelineIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkGeometryTrianglesNV(const VkGeometryTrianglesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBuffer(object.vertexData, settings, "VkBuffer", "vertexData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vertexOffset, settings, "VkDeviceSize", "vertexOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vertexCount, settings, "uint32_t", "vertexCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vertexStride, settings, "VkDeviceSize", "vertexStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormat(object.vertexFormat, settings, "VkFormat", "vertexFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBuffer(object.indexData, settings, "VkBuffer", "indexData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.indexOffset, settings, "VkDeviceSize", "indexOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.indexCount, settings, "uint32_t", "indexCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkIndexType(object.indexType, settings, "VkIndexType", "indexType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBuffer(object.transformData, settings, "VkBuffer", "transformData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.transformOffset, settings, "VkDeviceSize", "transformOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkGeometryAABBNV(const VkGeometryAABBNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBuffer(object.aabbData, settings, "VkBuffer", "aabbData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.numAABBs, settings, "uint32_t", "numAABBs", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.stride, settings, "uint32_t", "stride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.offset, settings, "VkDeviceSize", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkGeometryDataNV(const VkGeometryDataNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkGeometryTrianglesNV(object.triangles, settings, "VkGeometryTrianglesNV", "triangles", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkGeometryAABBNV(object.aabbs, settings, "VkGeometryAABBNV", "aabbs", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkGeometryNV(const VkGeometryNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkGeometryTypeKHR(object.geometryType, settings, "VkGeometryTypeKHR", "geometryType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkGeometryDataNV(object.geometry, settings, "VkGeometryDataNV", "geometry", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkGeometryFlagsKHR(object.flags, settings, "VkGeometryFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAccelerationStructureInfoNV(const VkAccelerationStructureInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccelerationStructureTypeKHR(object.type, settings, "VkAccelerationStructureTypeNV", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBuildAccelerationStructureFlagsKHR(object.flags, settings, "VkBuildAccelerationStructureFlagsNV", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.instanceCount, settings, "uint32_t", "instanceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.geometryCount, settings, "uint32_t", "geometryCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pGeometries, object.geometryCount, settings, "const VkGeometryNV*", "pGeometries", "const VkGeometryNV", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkGeometryNV); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAccelerationStructureCreateInfoNV(const VkAccelerationStructureCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.compactedSize, settings, "VkDeviceSize", "compactedSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccelerationStructureInfoNV(object.info, settings, "VkAccelerationStructureInfoNV", "info", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBindAccelerationStructureMemoryInfoNV(const VkBindAccelerationStructureMemoryInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccelerationStructureNV(object.accelerationStructure, settings, "VkAccelerationStructureNV", "accelerationStructure", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceMemory(object.memory, settings, "VkDeviceMemory", "memory", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.memoryOffset, settings, "VkDeviceSize", "memoryOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.deviceIndexCount, settings, "uint32_t", "deviceIndexCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pDeviceIndices, object.deviceIndexCount, settings, "const uint32_t*", "pDeviceIndices", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkWriteDescriptorSetAccelerationStructureNV(const VkWriteDescriptorSetAccelerationStructureNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.accelerationStructureCount, settings, "uint32_t", "accelerationStructureCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pAccelerationStructures, object.accelerationStructureCount, settings, "const VkAccelerationStructureNV*", "pAccelerationStructures", "const VkAccelerationStructureNV", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkAccelerationStructureNV); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAccelerationStructureMemoryRequirementsInfoNV(const VkAccelerationStructureMemoryRequirementsInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccelerationStructureMemoryRequirementsTypeNV(object.type, settings, "VkAccelerationStructureMemoryRequirementsTypeNV", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccelerationStructureNV(object.accelerationStructure, settings, "VkAccelerationStructureNV", "accelerationStructure", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceRayTracingPropertiesNV(const VkPhysicalDeviceRayTracingPropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderGroupHandleSize, settings, "uint32_t", "shaderGroupHandleSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxRecursionDepth, settings, "uint32_t", "maxRecursionDepth", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxShaderGroupStride, settings, "uint32_t", "maxShaderGroupStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderGroupBaseAlignment, settings, "uint32_t", "shaderGroupBaseAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxGeometryCount, settings, "uint64_t", "maxGeometryCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxInstanceCount, settings, "uint64_t", "maxInstanceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxTriangleCount, settings, "uint64_t", "maxTriangleCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDescriptorSetAccelerationStructures, settings, "uint32_t", "maxDescriptorSetAccelerationStructures", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkTransformMatrixKHR(const VkTransformMatrixKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_double_array(object.matrix, 3, 4, settings, "float[3][4]", "matrix", "float", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAabbPositionsKHR(const VkAabbPositionsKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.minX, settings, "float", "minX", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minY, settings, "float", "minY", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minZ, settings, "float", "minZ", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxX, settings, "float", "maxX", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxY, settings, "float", "maxY", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxZ, settings, "float", "maxZ", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAccelerationStructureInstanceKHR(const VkAccelerationStructureInstanceKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkTransformMatrixKHR(object.transform, settings, "VkTransformMatrixKHR", "transform", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.instanceCustomIndex, settings, "uint32_t:24", "instanceCustomIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.mask, settings, "uint32_t:8", "mask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.instanceShaderBindingTableRecordOffset, settings, "uint32_t:24", "instanceShaderBindingTableRecordOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkGeometryInstanceFlagsKHR(object.flags, settings, "VkGeometryInstanceFlagsKHR:8", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.accelerationStructureReference, settings, "uint64_t", "accelerationStructureReference", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.representativeFragmentTest, settings, "VkBool32", "representativeFragmentTest", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(const VkPipelineRepresentativeFragmentTestStateCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.representativeFragmentTestEnable, settings, "VkBool32", "representativeFragmentTestEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceImageViewImageFormatInfoEXT(const VkPhysicalDeviceImageViewImageFormatInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageViewType(object.imageViewType, settings, "VkImageViewType", "imageViewType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkFilterCubicImageViewImageFormatPropertiesEXT(const VkFilterCubicImageViewImageFormatPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.filterCubic, settings, "VkBool32", "filterCubic", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.filterCubicMinmax, settings, "VkBool32", "filterCubicMinmax", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImportMemoryHostPointerInfoEXT(const VkImportMemoryHostPointerInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalMemoryHandleTypeFlagBits(object.handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pHostPointer, settings, "void*", "pHostPointer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMemoryHostPointerPropertiesEXT(const VkMemoryHostPointerPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.memoryTypeBits, settings, "uint32_t", "memoryTypeBits", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(const VkPhysicalDeviceExternalMemoryHostPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minImportedHostPointerAlignment, settings, "VkDeviceSize", "minImportedHostPointerAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineCompilerControlCreateInfoAMD(const VkPipelineCompilerControlCreateInfoAMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineCompilerControlFlagsAMD(object.compilerControlFlags, settings, "VkPipelineCompilerControlFlagsAMD", "compilerControlFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderCorePropertiesAMD(const VkPhysicalDeviceShaderCorePropertiesAMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderEngineCount, settings, "uint32_t", "shaderEngineCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderArraysPerEngineCount, settings, "uint32_t", "shaderArraysPerEngineCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.computeUnitsPerShaderArray, settings, "uint32_t", "computeUnitsPerShaderArray", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.simdPerComputeUnit, settings, "uint32_t", "simdPerComputeUnit", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.wavefrontsPerSimd, settings, "uint32_t", "wavefrontsPerSimd", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.wavefrontSize, settings, "uint32_t", "wavefrontSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sgprsPerSimd, settings, "uint32_t", "sgprsPerSimd", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minSgprAllocation, settings, "uint32_t", "minSgprAllocation", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxSgprAllocation, settings, "uint32_t", "maxSgprAllocation", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sgprAllocationGranularity, settings, "uint32_t", "sgprAllocationGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vgprsPerSimd, settings, "uint32_t", "vgprsPerSimd", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minVgprAllocation, settings, "uint32_t", "minVgprAllocation", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxVgprAllocation, settings, "uint32_t", "maxVgprAllocation", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vgprAllocationGranularity, settings, "uint32_t", "vgprAllocationGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDeviceMemoryOverallocationCreateInfoAMD(const VkDeviceMemoryOverallocationCreateInfoAMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkMemoryOverallocationBehaviorAMD(object.overallocationBehavior, settings, "VkMemoryOverallocationBehaviorAMD", "overallocationBehavior", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxVertexAttribDivisor, settings, "uint32_t", "maxVertexAttribDivisor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#if defined(VK_USE_PLATFORM_GGP) +template +void dump_VkPresentFrameTokenGGP(const VkPresentFrameTokenGGP& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.frameToken, settings, "GgpFrameToken", "frameToken", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#endif // VK_USE_PLATFORM_GGP +template +void dump_VkPhysicalDeviceMeshShaderFeaturesNV(const VkPhysicalDeviceMeshShaderFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.taskShader, settings, "VkBool32", "taskShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.meshShader, settings, "VkBool32", "meshShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceMeshShaderPropertiesNV(const VkPhysicalDeviceMeshShaderPropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDrawMeshTasksCount, settings, "uint32_t", "maxDrawMeshTasksCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxTaskWorkGroupInvocations, settings, "uint32_t", "maxTaskWorkGroupInvocations", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.maxTaskWorkGroupSize, 3, settings, "uint32_t[3]", "maxTaskWorkGroupSize", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.maxTaskTotalMemorySize, settings, "uint32_t", "maxTaskTotalMemorySize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxTaskOutputCount, settings, "uint32_t", "maxTaskOutputCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxMeshWorkGroupInvocations, settings, "uint32_t", "maxMeshWorkGroupInvocations", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.maxMeshWorkGroupSize, 3, settings, "uint32_t[3]", "maxMeshWorkGroupSize", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.maxMeshTotalMemorySize, settings, "uint32_t", "maxMeshTotalMemorySize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxMeshOutputVertices, settings, "uint32_t", "maxMeshOutputVertices", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxMeshOutputPrimitives, settings, "uint32_t", "maxMeshOutputPrimitives", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxMeshMultiviewViewCount, settings, "uint32_t", "maxMeshMultiviewViewCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.meshOutputPerVertexGranularity, settings, "uint32_t", "meshOutputPerVertexGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.meshOutputPerPrimitiveGranularity, settings, "uint32_t", "meshOutputPerPrimitiveGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDrawMeshTasksIndirectCommandNV(const VkDrawMeshTasksIndirectCommandNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.taskCount, settings, "uint32_t", "taskCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.firstTask, settings, "uint32_t", "firstTask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderImageFootprintFeaturesNV(const VkPhysicalDeviceShaderImageFootprintFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.imageFootprint, settings, "VkBool32", "imageFootprint", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineViewportExclusiveScissorStateCreateInfoNV(const VkPipelineViewportExclusiveScissorStateCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.exclusiveScissorCount, settings, "uint32_t", "exclusiveScissorCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pExclusiveScissors, object.exclusiveScissorCount, settings, "const VkRect2D*", "pExclusiveScissors", "const VkRect2D", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkRect2D); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceExclusiveScissorFeaturesNV(const VkPhysicalDeviceExclusiveScissorFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.exclusiveScissor, settings, "VkBool32", "exclusiveScissor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkQueueFamilyCheckpointPropertiesNV(const VkQueueFamilyCheckpointPropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineStageFlags(object.checkpointExecutionStageMask, settings, "VkPipelineStageFlags", "checkpointExecutionStageMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCheckpointDataNV(const VkCheckpointDataNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineStageFlagBits(object.stage, settings, "VkPipelineStageFlagBits", "stage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pCheckpointMarker, settings, "void*", "pCheckpointMarker", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkQueueFamilyCheckpointProperties2NV(const VkQueueFamilyCheckpointProperties2NV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineStageFlags2(object.checkpointExecutionStageMask, settings, "VkPipelineStageFlags2", "checkpointExecutionStageMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCheckpointData2NV(const VkCheckpointData2NV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineStageFlags2(object.stage, settings, "VkPipelineStageFlags2", "stage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pCheckpointMarker, settings, "void*", "pCheckpointMarker", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDevicePresentTimingFeaturesEXT(const VkPhysicalDevicePresentTimingFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.presentTiming, settings, "VkBool32", "presentTiming", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.presentAtAbsoluteTime, settings, "VkBool32", "presentAtAbsoluteTime", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.presentAtRelativeTime, settings, "VkBool32", "presentAtRelativeTime", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPresentTimingSurfaceCapabilitiesEXT(const VkPresentTimingSurfaceCapabilitiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.presentTimingSupported, settings, "VkBool32", "presentTimingSupported", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.presentAtAbsoluteTimeSupported, settings, "VkBool32", "presentAtAbsoluteTimeSupported", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.presentAtRelativeTimeSupported, settings, "VkBool32", "presentAtRelativeTimeSupported", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPresentStageFlagsEXT(object.presentStageQueries, settings, "VkPresentStageFlagsEXT", "presentStageQueries", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSwapchainCalibratedTimestampInfoEXT(const VkSwapchainCalibratedTimestampInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSwapchainKHR(object.swapchain, settings, "VkSwapchainKHR", "swapchain", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPresentStageFlagsEXT(object.presentStage, settings, "VkPresentStageFlagsEXT", "presentStage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.timeDomainId, settings, "uint64_t", "timeDomainId", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSwapchainTimingPropertiesEXT(const VkSwapchainTimingPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.refreshDuration, settings, "uint64_t", "refreshDuration", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.refreshInterval, settings, "uint64_t", "refreshInterval", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSwapchainTimeDomainPropertiesEXT(const VkSwapchainTimeDomainPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.timeDomainCount, settings, "uint32_t", "timeDomainCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pTimeDomains, object.timeDomainCount, settings, "VkTimeDomainKHR*", "pTimeDomains", "VkTimeDomainKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkTimeDomainKHR); + dump_separate_members(settings); + dump_pointer_array(object.pTimeDomainIds, object.timeDomainCount, settings, "uint64_t*", "pTimeDomainIds", "uint64_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPastPresentationTimingInfoEXT(const VkPastPresentationTimingInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPastPresentationTimingFlagsEXT(object.flags, settings, "VkPastPresentationTimingFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSwapchainKHR(object.swapchain, settings, "VkSwapchainKHR", "swapchain", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPresentStageTimeEXT(const VkPresentStageTimeEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkPresentStageFlagsEXT(object.stage, settings, "VkPresentStageFlagsEXT", "stage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.time, settings, "uint64_t", "time", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPastPresentationTimingEXT(const VkPastPresentationTimingEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.presentId, settings, "uint64_t", "presentId", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.targetTime, settings, "uint64_t", "targetTime", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.presentStageCount, settings, "uint32_t", "presentStageCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pPresentStages, object.presentStageCount, settings, "VkPresentStageTimeEXT*", "pPresentStages", "VkPresentStageTimeEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPresentStageTimeEXT); + dump_separate_members(settings); + dump_VkTimeDomainKHR(object.timeDomain, settings, "VkTimeDomainKHR", "timeDomain", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.timeDomainId, settings, "uint64_t", "timeDomainId", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reportComplete, settings, "VkBool32", "reportComplete", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPastPresentationTimingPropertiesEXT(const VkPastPresentationTimingPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.timingPropertiesCounter, settings, "uint64_t", "timingPropertiesCounter", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.timeDomainsCounter, settings, "uint64_t", "timeDomainsCounter", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.presentationTimingCount, settings, "uint32_t", "presentationTimingCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pPresentationTimings, object.presentationTimingCount, settings, "VkPastPresentationTimingEXT*", "pPresentationTimings", "VkPastPresentationTimingEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPastPresentationTimingEXT); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPresentTimingInfoEXT(const VkPresentTimingInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPresentTimingInfoFlagsEXT(object.flags, settings, "VkPresentTimingInfoFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.targetTime, settings, "uint64_t", "targetTime", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.timeDomainId, settings, "uint64_t", "timeDomainId", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPresentStageFlagsEXT(object.presentStageQueries, settings, "VkPresentStageFlagsEXT", "presentStageQueries", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPresentStageFlagsEXT(object.targetTimeDomainPresentStage, settings, "VkPresentStageFlagsEXT", "targetTimeDomainPresentStage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPresentTimingsInfoEXT(const VkPresentTimingsInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.swapchainCount, settings, "uint32_t", "swapchainCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pTimingInfos, object.swapchainCount, settings, "const VkPresentTimingInfoEXT*", "pTimingInfos", "const VkPresentTimingInfoEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPresentTimingInfoEXT); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderIntegerFunctions2, settings, "VkBool32", "shaderIntegerFunctions2", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPerformanceValueDataINTEL(const VkPerformanceValueDataINTEL& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_union, type_name, var_name, indents, address); + dump_type(object.value32, settings, "uint32_t", "value32", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.value64, settings, "uint64_t", "value64", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.valueFloat, settings, "float", "valueFloat", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.valueBool, settings, "VkBool32", "valueBool", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_char(object.valueString, settings, "const char*", "valueString", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPerformanceValueINTEL(const VkPerformanceValueINTEL& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkPerformanceValueTypeINTEL(object.type, settings, "VkPerformanceValueTypeINTEL", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPerformanceValueDataINTEL(object.data, settings, "VkPerformanceValueDataINTEL", "data", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkInitializePerformanceApiInfoINTEL(const VkInitializePerformanceApiInfoINTEL& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pUserData, settings, "void*", "pUserData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkQueryPoolPerformanceQueryCreateInfoINTEL(const VkQueryPoolPerformanceQueryCreateInfoINTEL& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkQueryPoolSamplingModeINTEL(object.performanceCountersSampling, settings, "VkQueryPoolSamplingModeINTEL", "performanceCountersSampling", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPerformanceMarkerInfoINTEL(const VkPerformanceMarkerInfoINTEL& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.marker, settings, "uint64_t", "marker", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPerformanceStreamMarkerInfoINTEL(const VkPerformanceStreamMarkerInfoINTEL& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.marker, settings, "uint32_t", "marker", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPerformanceOverrideInfoINTEL(const VkPerformanceOverrideInfoINTEL& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPerformanceOverrideTypeINTEL(object.type, settings, "VkPerformanceOverrideTypeINTEL", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.enable, settings, "VkBool32", "enable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.parameter, settings, "uint64_t", "parameter", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPerformanceConfigurationAcquireInfoINTEL(const VkPerformanceConfigurationAcquireInfoINTEL& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPerformanceConfigurationTypeINTEL(object.type, settings, "VkPerformanceConfigurationTypeINTEL", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDevicePCIBusInfoPropertiesEXT(const VkPhysicalDevicePCIBusInfoPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pciDomain, settings, "uint32_t", "pciDomain", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pciBus, settings, "uint32_t", "pciBus", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pciDevice, settings, "uint32_t", "pciDevice", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pciFunction, settings, "uint32_t", "pciFunction", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDisplayNativeHdrSurfaceCapabilitiesAMD(const VkDisplayNativeHdrSurfaceCapabilitiesAMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.localDimmingSupport, settings, "VkBool32", "localDimmingSupport", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSwapchainDisplayNativeHdrCreateInfoAMD(const VkSwapchainDisplayNativeHdrCreateInfoAMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.localDimmingEnable, settings, "VkBool32", "localDimmingEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#if defined(VK_USE_PLATFORM_FUCHSIA) +template +void dump_VkImagePipeSurfaceCreateInfoFUCHSIA(const VkImagePipeSurfaceCreateInfoFUCHSIA& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImagePipeSurfaceCreateFlagsFUCHSIA(object.flags, settings, "VkImagePipeSurfaceCreateFlagsFUCHSIA", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.imagePipeHandle, settings, "zx_handle_t", "imagePipeHandle", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#endif // VK_USE_PLATFORM_FUCHSIA +#if defined(VK_USE_PLATFORM_METAL_EXT) +template +void dump_VkMetalSurfaceCreateInfoEXT(const VkMetalSurfaceCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkMetalSurfaceCreateFlagsEXT(object.flags, settings, "VkMetalSurfaceCreateFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pLayer, settings, "const CAMetalLayer*", "pLayer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#endif // VK_USE_PLATFORM_METAL_EXT +template +void dump_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(const VkPhysicalDeviceFragmentDensityMapFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.fragmentDensityMap, settings, "VkBool32", "fragmentDensityMap", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.fragmentDensityMapDynamic, settings, "VkBool32", "fragmentDensityMapDynamic", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.fragmentDensityMapNonSubsampledImages, settings, "VkBool32", "fragmentDensityMapNonSubsampledImages", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(const VkPhysicalDeviceFragmentDensityMapPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.minFragmentDensityTexelSize, settings, "VkExtent2D", "minFragmentDensityTexelSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.maxFragmentDensityTexelSize, settings, "VkExtent2D", "maxFragmentDensityTexelSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.fragmentDensityInvocations, settings, "VkBool32", "fragmentDensityInvocations", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkRenderPassFragmentDensityMapCreateInfoEXT(const VkRenderPassFragmentDensityMapCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAttachmentReference(object.fragmentDensityMapAttachment, settings, "VkAttachmentReference", "fragmentDensityMapAttachment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkRenderingFragmentDensityMapAttachmentInfoEXT(const VkRenderingFragmentDensityMapAttachmentInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageView(object.imageView, settings, "VkImageView", "imageView", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(object.imageLayout, settings, "VkImageLayout", "imageLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderCoreProperties2AMD(const VkPhysicalDeviceShaderCoreProperties2AMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkShaderCorePropertiesFlagsAMD(object.shaderCoreFeatures, settings, "VkShaderCorePropertiesFlagsAMD", "shaderCoreFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.activeComputeUnitCount, settings, "uint32_t", "activeComputeUnitCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceCoherentMemoryFeaturesAMD(const VkPhysicalDeviceCoherentMemoryFeaturesAMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.deviceCoherentMemory, settings, "VkBool32", "deviceCoherentMemory", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderImageInt64Atomics, settings, "VkBool32", "shaderImageInt64Atomics", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sparseImageInt64Atomics, settings, "VkBool32", "sparseImageInt64Atomics", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceMemoryBudgetPropertiesEXT(const VkPhysicalDeviceMemoryBudgetPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.heapBudget, std::min(ApiDumpInstance::current().getMemoryHeapCount(), VK_MAX_MEMORY_HEAPS), settings, "VkDeviceSize[VK_MAX_MEMORY_HEAPS]", "heapBudget", "VkDeviceSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.heapUsage, std::min(ApiDumpInstance::current().getMemoryHeapCount(), VK_MAX_MEMORY_HEAPS), settings, "VkDeviceSize[VK_MAX_MEMORY_HEAPS]", "heapUsage", "VkDeviceSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceMemoryPriorityFeaturesEXT(const VkPhysicalDeviceMemoryPriorityFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.memoryPriority, settings, "VkBool32", "memoryPriority", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMemoryPriorityAllocateInfoEXT(const VkMemoryPriorityAllocateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.priority, settings, "float", "priority", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dedicatedAllocationImageAliasing, settings, "VkBool32", "dedicatedAllocationImageAliasing", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bufferDeviceAddress, settings, "VkBool32", "bufferDeviceAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bufferDeviceAddressCaptureReplay, settings, "VkBool32", "bufferDeviceAddressCaptureReplay", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bufferDeviceAddressMultiDevice, settings, "VkBool32", "bufferDeviceAddressMultiDevice", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBufferDeviceAddressCreateInfoEXT(const VkBufferDeviceAddressCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type_hex(object.deviceAddress, settings, "VkDeviceAddress", "deviceAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkValidationFeaturesEXT(const VkValidationFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.enabledValidationFeatureCount, settings, "uint32_t", "enabledValidationFeatureCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pEnabledValidationFeatures, object.enabledValidationFeatureCount, settings, "const VkValidationFeatureEnableEXT*", "pEnabledValidationFeatures", "const VkValidationFeatureEnableEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkValidationFeatureEnableEXT); + dump_separate_members(settings); + dump_type(object.disabledValidationFeatureCount, settings, "uint32_t", "disabledValidationFeatureCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pDisabledValidationFeatures, object.disabledValidationFeatureCount, settings, "const VkValidationFeatureDisableEXT*", "pDisabledValidationFeatures", "const VkValidationFeatureDisableEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkValidationFeatureDisableEXT); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCooperativeMatrixPropertiesNV(const VkCooperativeMatrixPropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.MSize, settings, "uint32_t", "MSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.NSize, settings, "uint32_t", "NSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.KSize, settings, "uint32_t", "KSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkComponentTypeKHR(object.AType, settings, "VkComponentTypeNV", "AType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkComponentTypeKHR(object.BType, settings, "VkComponentTypeNV", "BType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkComponentTypeKHR(object.CType, settings, "VkComponentTypeNV", "CType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkComponentTypeKHR(object.DType, settings, "VkComponentTypeNV", "DType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkScopeKHR(object.scope, settings, "VkScopeNV", "scope", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceCooperativeMatrixFeaturesNV(const VkPhysicalDeviceCooperativeMatrixFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.cooperativeMatrix, settings, "VkBool32", "cooperativeMatrix", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.cooperativeMatrixRobustBufferAccess, settings, "VkBool32", "cooperativeMatrixRobustBufferAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceCooperativeMatrixPropertiesNV(const VkPhysicalDeviceCooperativeMatrixPropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkShaderStageFlags(object.cooperativeMatrixSupportedStages, settings, "VkShaderStageFlags", "cooperativeMatrixSupportedStages", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceCoverageReductionModeFeaturesNV(const VkPhysicalDeviceCoverageReductionModeFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.coverageReductionMode, settings, "VkBool32", "coverageReductionMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineCoverageReductionStateCreateInfoNV(const VkPipelineCoverageReductionStateCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineCoverageReductionStateCreateFlagsNV(object.flags, settings, "VkPipelineCoverageReductionStateCreateFlagsNV", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkCoverageReductionModeNV(object.coverageReductionMode, settings, "VkCoverageReductionModeNV", "coverageReductionMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkFramebufferMixedSamplesCombinationNV(const VkFramebufferMixedSamplesCombinationNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkCoverageReductionModeNV(object.coverageReductionMode, settings, "VkCoverageReductionModeNV", "coverageReductionMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSampleCountFlagBits(object.rasterizationSamples, settings, "VkSampleCountFlagBits", "rasterizationSamples", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSampleCountFlags(object.depthStencilSamples, settings, "VkSampleCountFlags", "depthStencilSamples", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSampleCountFlags(object.colorSamples, settings, "VkSampleCountFlags", "colorSamples", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.fragmentShaderSampleInterlock, settings, "VkBool32", "fragmentShaderSampleInterlock", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.fragmentShaderPixelInterlock, settings, "VkBool32", "fragmentShaderPixelInterlock", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.fragmentShaderShadingRateInterlock, settings, "VkBool32", "fragmentShaderShadingRateInterlock", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.ycbcrImageArrays, settings, "VkBool32", "ycbcrImageArrays", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceProvokingVertexFeaturesEXT(const VkPhysicalDeviceProvokingVertexFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.provokingVertexLast, settings, "VkBool32", "provokingVertexLast", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.transformFeedbackPreservesProvokingVertex, settings, "VkBool32", "transformFeedbackPreservesProvokingVertex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceProvokingVertexPropertiesEXT(const VkPhysicalDeviceProvokingVertexPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.provokingVertexModePerPipeline, settings, "VkBool32", "provokingVertexModePerPipeline", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.transformFeedbackPreservesTriangleFanProvokingVertex, settings, "VkBool32", "transformFeedbackPreservesTriangleFanProvokingVertex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkProvokingVertexModeEXT(object.provokingVertexMode, settings, "VkProvokingVertexModeEXT", "provokingVertexMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#if defined(VK_USE_PLATFORM_WIN32_KHR) +template +void dump_VkSurfaceFullScreenExclusiveInfoEXT(const VkSurfaceFullScreenExclusiveInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFullScreenExclusiveEXT(object.fullScreenExclusive, settings, "VkFullScreenExclusiveEXT", "fullScreenExclusive", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSurfaceCapabilitiesFullScreenExclusiveEXT(const VkSurfaceCapabilitiesFullScreenExclusiveEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.fullScreenExclusiveSupported, settings, "VkBool32", "fullScreenExclusiveSupported", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSurfaceFullScreenExclusiveWin32InfoEXT(const VkSurfaceFullScreenExclusiveWin32InfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.hmonitor, settings, "HMONITOR", "hmonitor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#endif // VK_USE_PLATFORM_WIN32_KHR +template +void dump_VkHeadlessSurfaceCreateInfoEXT(const VkHeadlessSurfaceCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkHeadlessSurfaceCreateFlagsEXT(object.flags, settings, "VkHeadlessSurfaceCreateFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderBufferFloat32Atomics, settings, "VkBool32", "shaderBufferFloat32Atomics", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderBufferFloat32AtomicAdd, settings, "VkBool32", "shaderBufferFloat32AtomicAdd", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderBufferFloat64Atomics, settings, "VkBool32", "shaderBufferFloat64Atomics", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderBufferFloat64AtomicAdd, settings, "VkBool32", "shaderBufferFloat64AtomicAdd", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderSharedFloat32Atomics, settings, "VkBool32", "shaderSharedFloat32Atomics", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderSharedFloat32AtomicAdd, settings, "VkBool32", "shaderSharedFloat32AtomicAdd", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderSharedFloat64Atomics, settings, "VkBool32", "shaderSharedFloat64Atomics", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderSharedFloat64AtomicAdd, settings, "VkBool32", "shaderSharedFloat64AtomicAdd", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderImageFloat32Atomics, settings, "VkBool32", "shaderImageFloat32Atomics", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderImageFloat32AtomicAdd, settings, "VkBool32", "shaderImageFloat32AtomicAdd", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sparseImageFloat32Atomics, settings, "VkBool32", "sparseImageFloat32Atomics", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sparseImageFloat32AtomicAdd, settings, "VkBool32", "sparseImageFloat32AtomicAdd", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.extendedDynamicState, settings, "VkBool32", "extendedDynamicState", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT(const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.memoryMapPlaced, settings, "VkBool32", "memoryMapPlaced", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.memoryMapRangePlaced, settings, "VkBool32", "memoryMapRangePlaced", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.memoryUnmapReserve, settings, "VkBool32", "memoryUnmapReserve", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT(const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minPlacedMemoryMapAlignment, settings, "VkDeviceSize", "minPlacedMemoryMapAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMemoryMapPlacedInfoEXT(const VkMemoryMapPlacedInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pPlacedAddress, settings, "void*", "pPlacedAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderBufferFloat16Atomics, settings, "VkBool32", "shaderBufferFloat16Atomics", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderBufferFloat16AtomicAdd, settings, "VkBool32", "shaderBufferFloat16AtomicAdd", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderBufferFloat16AtomicMinMax, settings, "VkBool32", "shaderBufferFloat16AtomicMinMax", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderBufferFloat32AtomicMinMax, settings, "VkBool32", "shaderBufferFloat32AtomicMinMax", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderBufferFloat64AtomicMinMax, settings, "VkBool32", "shaderBufferFloat64AtomicMinMax", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderSharedFloat16Atomics, settings, "VkBool32", "shaderSharedFloat16Atomics", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderSharedFloat16AtomicAdd, settings, "VkBool32", "shaderSharedFloat16AtomicAdd", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderSharedFloat16AtomicMinMax, settings, "VkBool32", "shaderSharedFloat16AtomicMinMax", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderSharedFloat32AtomicMinMax, settings, "VkBool32", "shaderSharedFloat32AtomicMinMax", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderSharedFloat64AtomicMinMax, settings, "VkBool32", "shaderSharedFloat64AtomicMinMax", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderImageFloat32AtomicMinMax, settings, "VkBool32", "shaderImageFloat32AtomicMinMax", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sparseImageFloat32AtomicMinMax, settings, "VkBool32", "sparseImageFloat32AtomicMinMax", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxGraphicsShaderGroupCount, settings, "uint32_t", "maxGraphicsShaderGroupCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxIndirectSequenceCount, settings, "uint32_t", "maxIndirectSequenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxIndirectCommandsTokenCount, settings, "uint32_t", "maxIndirectCommandsTokenCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxIndirectCommandsStreamCount, settings, "uint32_t", "maxIndirectCommandsStreamCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxIndirectCommandsTokenOffset, settings, "uint32_t", "maxIndirectCommandsTokenOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxIndirectCommandsStreamStride, settings, "uint32_t", "maxIndirectCommandsStreamStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minSequencesCountBufferOffsetAlignment, settings, "uint32_t", "minSequencesCountBufferOffsetAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minSequencesIndexBufferOffsetAlignment, settings, "uint32_t", "minSequencesIndexBufferOffsetAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minIndirectCommandsBufferOffsetAlignment, settings, "uint32_t", "minIndirectCommandsBufferOffsetAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.deviceGeneratedCommands, settings, "VkBool32", "deviceGeneratedCommands", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkGraphicsShaderGroupCreateInfoNV(const VkGraphicsShaderGroupCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.stageCount, settings, "uint32_t", "stageCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pStages, object.stageCount, settings, "const VkPipelineShaderStageCreateInfo*", "pStages", "const VkPipelineShaderStageCreateInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineShaderStageCreateInfo); + dump_separate_members(settings); + dump_pointer(object.pVertexInputState, settings, "const VkPipelineVertexInputStateCreateInfo*", "pVertexInputState", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineVertexInputStateCreateInfo); + dump_separate_members(settings); + dump_pointer(object.pTessellationState, settings, "const VkPipelineTessellationStateCreateInfo*", "pTessellationState", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineTessellationStateCreateInfo); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkGraphicsPipelineShaderGroupsCreateInfoNV(const VkGraphicsPipelineShaderGroupsCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.groupCount, settings, "uint32_t", "groupCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pGroups, object.groupCount, settings, "const VkGraphicsShaderGroupCreateInfoNV*", "pGroups", "const VkGraphicsShaderGroupCreateInfoNV", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkGraphicsShaderGroupCreateInfoNV); + dump_separate_members(settings); + dump_type(object.pipelineCount, settings, "uint32_t", "pipelineCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pPipelines, object.pipelineCount, settings, "const VkPipeline*", "pPipelines", "const VkPipeline", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipeline); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBindShaderGroupIndirectCommandNV(const VkBindShaderGroupIndirectCommandNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.groupIndex, settings, "uint32_t", "groupIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBindIndexBufferIndirectCommandNV(const VkBindIndexBufferIndirectCommandNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type_hex(object.bufferAddress, settings, "VkDeviceAddress", "bufferAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.size, settings, "uint32_t", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkIndexType(object.indexType, settings, "VkIndexType", "indexType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBindVertexBufferIndirectCommandNV(const VkBindVertexBufferIndirectCommandNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type_hex(object.bufferAddress, settings, "VkDeviceAddress", "bufferAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.size, settings, "uint32_t", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.stride, settings, "uint32_t", "stride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSetStateFlagsIndirectCommandNV(const VkSetStateFlagsIndirectCommandNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.data, settings, "uint32_t", "data", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkIndirectCommandsStreamNV(const VkIndirectCommandsStreamNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkBuffer(object.buffer, settings, "VkBuffer", "buffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.offset, settings, "VkDeviceSize", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkIndirectCommandsLayoutTokenNV(const VkIndirectCommandsLayoutTokenNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkIndirectCommandsTokenTypeNV(object.tokenType, settings, "VkIndirectCommandsTokenTypeNV", "tokenType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.stream, settings, "uint32_t", "stream", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.offset, settings, "uint32_t", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vertexBindingUnit, settings, "uint32_t", "vertexBindingUnit", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vertexDynamicStride, settings, "VkBool32", "vertexDynamicStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineLayout(object.pushconstantPipelineLayout, settings, "VkPipelineLayout", "pushconstantPipelineLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkShaderStageFlags(object.pushconstantShaderStageFlags, settings, "VkShaderStageFlags", "pushconstantShaderStageFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pushconstantOffset, settings, "uint32_t", "pushconstantOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pushconstantSize, settings, "uint32_t", "pushconstantSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkIndirectStateFlagsNV(object.indirectStateFlags, settings, "VkIndirectStateFlagsNV", "indirectStateFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.indexTypeCount, settings, "uint32_t", "indexTypeCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pIndexTypes, object.indexTypeCount, settings, "const VkIndexType*", "pIndexTypes", "const VkIndexType", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkIndexType); + dump_separate_members(settings); + dump_pointer_array(object.pIndexTypeValues, object.indexTypeCount, settings, "const uint32_t*", "pIndexTypeValues", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkIndirectCommandsLayoutCreateInfoNV(const VkIndirectCommandsLayoutCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkIndirectCommandsLayoutUsageFlagsNV(object.flags, settings, "VkIndirectCommandsLayoutUsageFlagsNV", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineBindPoint(object.pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tokenCount, settings, "uint32_t", "tokenCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pTokens, object.tokenCount, settings, "const VkIndirectCommandsLayoutTokenNV*", "pTokens", "const VkIndirectCommandsLayoutTokenNV", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkIndirectCommandsLayoutTokenNV); + dump_separate_members(settings); + dump_type(object.streamCount, settings, "uint32_t", "streamCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pStreamStrides, object.streamCount, settings, "const uint32_t*", "pStreamStrides", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkGeneratedCommandsInfoNV(const VkGeneratedCommandsInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineBindPoint(object.pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipeline(object.pipeline, settings, "VkPipeline", "pipeline", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkIndirectCommandsLayoutNV(object.indirectCommandsLayout, settings, "VkIndirectCommandsLayoutNV", "indirectCommandsLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.streamCount, settings, "uint32_t", "streamCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pStreams, object.streamCount, settings, "const VkIndirectCommandsStreamNV*", "pStreams", "const VkIndirectCommandsStreamNV", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkIndirectCommandsStreamNV); + dump_separate_members(settings); + dump_type(object.sequencesCount, settings, "uint32_t", "sequencesCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBuffer(object.preprocessBuffer, settings, "VkBuffer", "preprocessBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.preprocessOffset, settings, "VkDeviceSize", "preprocessOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.preprocessSize, settings, "VkDeviceSize", "preprocessSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBuffer(object.sequencesCountBuffer, settings, "VkBuffer", "sequencesCountBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sequencesCountOffset, settings, "VkDeviceSize", "sequencesCountOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBuffer(object.sequencesIndexBuffer, settings, "VkBuffer", "sequencesIndexBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sequencesIndexOffset, settings, "VkDeviceSize", "sequencesIndexOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkGeneratedCommandsMemoryRequirementsInfoNV(const VkGeneratedCommandsMemoryRequirementsInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineBindPoint(object.pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipeline(object.pipeline, settings, "VkPipeline", "pipeline", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkIndirectCommandsLayoutNV(object.indirectCommandsLayout, settings, "VkIndirectCommandsLayoutNV", "indirectCommandsLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxSequencesCount, settings, "uint32_t", "maxSequencesCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(const VkPhysicalDeviceInheritedViewportScissorFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.inheritedViewportScissor2D, settings, "VkBool32", "inheritedViewportScissor2D", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCommandBufferInheritanceViewportScissorInfoNV(const VkCommandBufferInheritanceViewportScissorInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.viewportScissor2D, settings, "VkBool32", "viewportScissor2D", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.viewportDepthCount, settings, "uint32_t", "viewportDepthCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pViewportDepths, settings, "const VkViewport*", "pViewportDepths", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkViewport); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.texelBufferAlignment, settings, "VkBool32", "texelBufferAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkRenderPassTransformBeginInfoQCOM(const VkRenderPassTransformBeginInfoQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSurfaceTransformFlagBitsKHR(object.transform, settings, "VkSurfaceTransformFlagBitsKHR", "transform", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(const VkCommandBufferInheritanceRenderPassTransformInfoQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSurfaceTransformFlagBitsKHR(object.transform, settings, "VkSurfaceTransformFlagBitsKHR", "transform", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkRect2D(object.renderArea, settings, "VkRect2D", "renderArea", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceDepthBiasControlFeaturesEXT(const VkPhysicalDeviceDepthBiasControlFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.depthBiasControl, settings, "VkBool32", "depthBiasControl", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.leastRepresentableValueForceUnormRepresentation, settings, "VkBool32", "leastRepresentableValueForceUnormRepresentation", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.floatRepresentation, settings, "VkBool32", "floatRepresentation", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.depthBiasExact, settings, "VkBool32", "depthBiasExact", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDepthBiasInfoEXT(const VkDepthBiasInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.depthBiasConstantFactor, settings, "float", "depthBiasConstantFactor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.depthBiasClamp, settings, "float", "depthBiasClamp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.depthBiasSlopeFactor, settings, "float", "depthBiasSlopeFactor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDepthBiasRepresentationInfoEXT(const VkDepthBiasRepresentationInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDepthBiasRepresentationEXT(object.depthBiasRepresentation, settings, "VkDepthBiasRepresentationEXT", "depthBiasRepresentation", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.depthBiasExact, settings, "VkBool32", "depthBiasExact", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.deviceMemoryReport, settings, "VkBool32", "deviceMemoryReport", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDeviceMemoryReportCallbackDataEXT(const VkDeviceMemoryReportCallbackDataEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceMemoryReportFlagsEXT(object.flags, settings, "VkDeviceMemoryReportFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceMemoryReportEventTypeEXT(object.type, settings, "VkDeviceMemoryReportEventTypeEXT", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.memoryObjectId, settings, "uint64_t", "memoryObjectId", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkObjectType(object.objectType, settings, "VkObjectType", "objectType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_uint64_t_as_pointer(object.objectHandle, settings, "uint64_t", "objectHandle", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.heapIndex, settings, "uint32_t", "heapIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDeviceDeviceMemoryReportCreateInfoEXT(const VkDeviceDeviceMemoryReportCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceMemoryReportFlagsEXT(object.flags, settings, "VkDeviceMemoryReportFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_PFN_vkDeviceMemoryReportCallbackEXT(object.pfnUserCallback, settings, "PFN_vkDeviceMemoryReportCallbackEXT", "pfnUserCallback", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pUserData, settings, "void*", "pUserData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceCustomBorderColorPropertiesEXT(const VkPhysicalDeviceCustomBorderColorPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxCustomBorderColorSamplers, settings, "uint32_t", "maxCustomBorderColorSamplers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceCustomBorderColorFeaturesEXT(const VkPhysicalDeviceCustomBorderColorFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.customBorderColors, settings, "VkBool32", "customBorderColors", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.customBorderColorWithoutFormat, settings, "VkBool32", "customBorderColorWithoutFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT(const VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.textureCompressionASTC_3D, settings, "VkBool32", "textureCompressionASTC_3D", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDevicePresentBarrierFeaturesNV(const VkPhysicalDevicePresentBarrierFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.presentBarrier, settings, "VkBool32", "presentBarrier", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSurfaceCapabilitiesPresentBarrierNV(const VkSurfaceCapabilitiesPresentBarrierNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.presentBarrierSupported, settings, "VkBool32", "presentBarrierSupported", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSwapchainPresentBarrierCreateInfoNV(const VkSwapchainPresentBarrierCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.presentBarrierEnable, settings, "VkBool32", "presentBarrierEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(const VkPhysicalDeviceDiagnosticsConfigFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.diagnosticsConfig, settings, "VkBool32", "diagnosticsConfig", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDeviceDiagnosticsConfigCreateInfoNV(const VkDeviceDiagnosticsConfigCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceDiagnosticsConfigFlagsNV(object.flags, settings, "VkDeviceDiagnosticsConfigFlagsNV", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#if defined(VK_ENABLE_BETA_EXTENSIONS) +template +void dump_VkCudaModuleCreateInfoNV(const VkCudaModuleCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dataSize, settings, "size_t", "dataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pData, settings, "const void*", "pData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCudaFunctionCreateInfoNV(const VkCudaFunctionCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkCudaModuleNV(object.module, settings, "VkCudaModuleNV", "module", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_char(object.pName, settings, "const char*", "pName", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCudaLaunchInfoNV(const VkCudaLaunchInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkCudaFunctionNV(object.function, settings, "VkCudaFunctionNV", "function", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.gridDimX, settings, "uint32_t", "gridDimX", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.gridDimY, settings, "uint32_t", "gridDimY", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.gridDimZ, settings, "uint32_t", "gridDimZ", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.blockDimX, settings, "uint32_t", "blockDimX", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.blockDimY, settings, "uint32_t", "blockDimY", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.blockDimZ, settings, "uint32_t", "blockDimZ", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sharedMemBytes, settings, "uint32_t", "sharedMemBytes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.paramCount, settings, "size_t", "paramCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pParams, object.paramCount, settings, "const void* const *", "pParams", "const void*", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.extraCount, settings, "size_t", "extraCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pExtras, object.extraCount, settings, "const void* const *", "pExtras", "const void*", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceCudaKernelLaunchFeaturesNV(const VkPhysicalDeviceCudaKernelLaunchFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.cudaKernelLaunchFeatures, settings, "VkBool32", "cudaKernelLaunchFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceCudaKernelLaunchPropertiesNV(const VkPhysicalDeviceCudaKernelLaunchPropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.computeCapabilityMinor, settings, "uint32_t", "computeCapabilityMinor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.computeCapabilityMajor, settings, "uint32_t", "computeCapabilityMajor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#endif // VK_ENABLE_BETA_EXTENSIONS +template +void dump_VkPhysicalDeviceTileShadingFeaturesQCOM(const VkPhysicalDeviceTileShadingFeaturesQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tileShading, settings, "VkBool32", "tileShading", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tileShadingFragmentStage, settings, "VkBool32", "tileShadingFragmentStage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tileShadingColorAttachments, settings, "VkBool32", "tileShadingColorAttachments", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tileShadingDepthAttachments, settings, "VkBool32", "tileShadingDepthAttachments", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tileShadingStencilAttachments, settings, "VkBool32", "tileShadingStencilAttachments", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tileShadingInputAttachments, settings, "VkBool32", "tileShadingInputAttachments", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tileShadingSampledAttachments, settings, "VkBool32", "tileShadingSampledAttachments", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tileShadingPerTileDraw, settings, "VkBool32", "tileShadingPerTileDraw", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tileShadingPerTileDispatch, settings, "VkBool32", "tileShadingPerTileDispatch", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tileShadingDispatchTile, settings, "VkBool32", "tileShadingDispatchTile", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tileShadingApron, settings, "VkBool32", "tileShadingApron", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tileShadingAnisotropicApron, settings, "VkBool32", "tileShadingAnisotropicApron", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tileShadingAtomicOps, settings, "VkBool32", "tileShadingAtomicOps", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tileShadingImageProcessing, settings, "VkBool32", "tileShadingImageProcessing", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceTileShadingPropertiesQCOM(const VkPhysicalDeviceTileShadingPropertiesQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxApronSize, settings, "uint32_t", "maxApronSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.preferNonCoherent, settings, "VkBool32", "preferNonCoherent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.tileGranularity, settings, "VkExtent2D", "tileGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.maxTileShadingRate, settings, "VkExtent2D", "maxTileShadingRate", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkRenderPassTileShadingCreateInfoQCOM(const VkRenderPassTileShadingCreateInfoQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkTileShadingRenderPassFlagsQCOM(object.flags, settings, "VkTileShadingRenderPassFlagsQCOM", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.tileApronSize, settings, "VkExtent2D", "tileApronSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPerTileBeginInfoQCOM(const VkPerTileBeginInfoQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPerTileEndInfoQCOM(const VkPerTileEndInfoQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDispatchTileInfoQCOM(const VkDispatchTileInfoQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkQueryLowLatencySupportNV(const VkQueryLowLatencySupportNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pQueriedLowLatencyData, settings, "void*", "pQueriedLowLatencyData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#if defined(VK_USE_PLATFORM_METAL_EXT) +template +void dump_VkExportMetalObjectCreateInfoEXT(const VkExportMetalObjectCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExportMetalObjectTypeFlagBitsEXT(object.exportObjectType, settings, "VkExportMetalObjectTypeFlagBitsEXT", "exportObjectType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkExportMetalObjectsInfoEXT(const VkExportMetalObjectsInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkExportMetalDeviceInfoEXT(const VkExportMetalDeviceInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.mtlDevice, settings, "MTLDevice_id", "mtlDevice", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkExportMetalCommandQueueInfoEXT(const VkExportMetalCommandQueueInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkQueue(object.queue, settings, "VkQueue", "queue", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.mtlCommandQueue, settings, "MTLCommandQueue_id", "mtlCommandQueue", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkExportMetalBufferInfoEXT(const VkExportMetalBufferInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceMemory(object.memory, settings, "VkDeviceMemory", "memory", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.mtlBuffer, settings, "MTLBuffer_id", "mtlBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImportMetalBufferInfoEXT(const VkImportMetalBufferInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.mtlBuffer, settings, "MTLBuffer_id", "mtlBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkExportMetalTextureInfoEXT(const VkExportMetalTextureInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImage(object.image, settings, "VkImage", "image", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageView(object.imageView, settings, "VkImageView", "imageView", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBufferView(object.bufferView, settings, "VkBufferView", "bufferView", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageAspectFlagBits(object.plane, settings, "VkImageAspectFlagBits", "plane", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.mtlTexture, settings, "MTLTexture_id", "mtlTexture", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImportMetalTextureInfoEXT(const VkImportMetalTextureInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageAspectFlagBits(object.plane, settings, "VkImageAspectFlagBits", "plane", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.mtlTexture, settings, "MTLTexture_id", "mtlTexture", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkExportMetalIOSurfaceInfoEXT(const VkExportMetalIOSurfaceInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImage(object.image, settings, "VkImage", "image", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.ioSurface, settings, "IOSurfaceRef", "ioSurface", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImportMetalIOSurfaceInfoEXT(const VkImportMetalIOSurfaceInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.ioSurface, settings, "IOSurfaceRef", "ioSurface", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkExportMetalSharedEventInfoEXT(const VkExportMetalSharedEventInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSemaphore(object.semaphore, settings, "VkSemaphore", "semaphore", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkEvent(object.event, settings, "VkEvent", "event", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.mtlSharedEvent, settings, "MTLSharedEvent_id", "mtlSharedEvent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImportMetalSharedEventInfoEXT(const VkImportMetalSharedEventInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.mtlSharedEvent, settings, "MTLSharedEvent_id", "mtlSharedEvent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#endif // VK_USE_PLATFORM_METAL_EXT +template +void dump_VkPhysicalDeviceDescriptorBufferPropertiesEXT(const VkPhysicalDeviceDescriptorBufferPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.combinedImageSamplerDescriptorSingleArray, settings, "VkBool32", "combinedImageSamplerDescriptorSingleArray", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bufferlessPushDescriptors, settings, "VkBool32", "bufferlessPushDescriptors", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.allowSamplerImageViewPostSubmitCreation, settings, "VkBool32", "allowSamplerImageViewPostSubmitCreation", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorBufferOffsetAlignment, settings, "VkDeviceSize", "descriptorBufferOffsetAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDescriptorBufferBindings, settings, "uint32_t", "maxDescriptorBufferBindings", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxResourceDescriptorBufferBindings, settings, "uint32_t", "maxResourceDescriptorBufferBindings", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxSamplerDescriptorBufferBindings, settings, "uint32_t", "maxSamplerDescriptorBufferBindings", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxEmbeddedImmutableSamplerBindings, settings, "uint32_t", "maxEmbeddedImmutableSamplerBindings", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxEmbeddedImmutableSamplers, settings, "uint32_t", "maxEmbeddedImmutableSamplers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bufferCaptureReplayDescriptorDataSize, settings, "size_t", "bufferCaptureReplayDescriptorDataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.imageCaptureReplayDescriptorDataSize, settings, "size_t", "imageCaptureReplayDescriptorDataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.imageViewCaptureReplayDescriptorDataSize, settings, "size_t", "imageViewCaptureReplayDescriptorDataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.samplerCaptureReplayDescriptorDataSize, settings, "size_t", "samplerCaptureReplayDescriptorDataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.accelerationStructureCaptureReplayDescriptorDataSize, settings, "size_t", "accelerationStructureCaptureReplayDescriptorDataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.samplerDescriptorSize, settings, "size_t", "samplerDescriptorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.combinedImageSamplerDescriptorSize, settings, "size_t", "combinedImageSamplerDescriptorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sampledImageDescriptorSize, settings, "size_t", "sampledImageDescriptorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.storageImageDescriptorSize, settings, "size_t", "storageImageDescriptorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.uniformTexelBufferDescriptorSize, settings, "size_t", "uniformTexelBufferDescriptorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.robustUniformTexelBufferDescriptorSize, settings, "size_t", "robustUniformTexelBufferDescriptorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.storageTexelBufferDescriptorSize, settings, "size_t", "storageTexelBufferDescriptorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.robustStorageTexelBufferDescriptorSize, settings, "size_t", "robustStorageTexelBufferDescriptorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.uniformBufferDescriptorSize, settings, "size_t", "uniformBufferDescriptorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.robustUniformBufferDescriptorSize, settings, "size_t", "robustUniformBufferDescriptorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.storageBufferDescriptorSize, settings, "size_t", "storageBufferDescriptorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.robustStorageBufferDescriptorSize, settings, "size_t", "robustStorageBufferDescriptorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.inputAttachmentDescriptorSize, settings, "size_t", "inputAttachmentDescriptorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.accelerationStructureDescriptorSize, settings, "size_t", "accelerationStructureDescriptorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxSamplerDescriptorBufferRange, settings, "VkDeviceSize", "maxSamplerDescriptorBufferRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxResourceDescriptorBufferRange, settings, "VkDeviceSize", "maxResourceDescriptorBufferRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.samplerDescriptorBufferAddressSpaceSize, settings, "VkDeviceSize", "samplerDescriptorBufferAddressSpaceSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.resourceDescriptorBufferAddressSpaceSize, settings, "VkDeviceSize", "resourceDescriptorBufferAddressSpaceSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorBufferAddressSpaceSize, settings, "VkDeviceSize", "descriptorBufferAddressSpaceSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.combinedImageSamplerDensityMapDescriptorSize, settings, "size_t", "combinedImageSamplerDensityMapDescriptorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceDescriptorBufferFeaturesEXT(const VkPhysicalDeviceDescriptorBufferFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorBuffer, settings, "VkBool32", "descriptorBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorBufferCaptureReplay, settings, "VkBool32", "descriptorBufferCaptureReplay", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorBufferImageLayoutIgnored, settings, "VkBool32", "descriptorBufferImageLayoutIgnored", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorBufferPushDescriptors, settings, "VkBool32", "descriptorBufferPushDescriptors", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDescriptorAddressInfoEXT(const VkDescriptorAddressInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type_hex(object.address, settings, "VkDeviceAddress", "address", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.range, settings, "VkDeviceSize", "range", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormat(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDescriptorBufferBindingInfoEXT(const VkDescriptorBufferBindingInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type_hex(object.address, settings, "VkDeviceAddress", "address", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBufferUsageFlags(object.usage, settings, "VkBufferUsageFlags", "usage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBuffer(object.buffer, settings, "VkBuffer", "buffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDescriptorDataEXT(const VkDescriptorDataEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_union, type_name, var_name, indents, address); + if (ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_SAMPLER) { + dump_pointer(object.pSampler, settings, "const VkSampler*", "pSampler", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSampler); + } + dump_separate_members(settings); + if (ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER) { + dump_pointer(object.pCombinedImageSampler, settings, "const VkDescriptorImageInfo*", "pCombinedImageSampler", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorImageInfo); + } + dump_separate_members(settings); + if (ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT) { + dump_pointer(object.pInputAttachmentImage, settings, "const VkDescriptorImageInfo*", "pInputAttachmentImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorImageInfo); + } + dump_separate_members(settings); + if (ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE) { + dump_pointer(object.pSampledImage, settings, "const VkDescriptorImageInfo*", "pSampledImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorImageInfo); + } + dump_separate_members(settings); + if (ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE) { + dump_pointer(object.pStorageImage, settings, "const VkDescriptorImageInfo*", "pStorageImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorImageInfo); + } + dump_separate_members(settings); + if (ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER) { + dump_pointer(object.pUniformTexelBuffer, settings, "const VkDescriptorAddressInfoEXT*", "pUniformTexelBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorAddressInfoEXT); + } + dump_separate_members(settings); + if (ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER) { + dump_pointer(object.pStorageTexelBuffer, settings, "const VkDescriptorAddressInfoEXT*", "pStorageTexelBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorAddressInfoEXT); + } + dump_separate_members(settings); + if (ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER) { + dump_pointer(object.pUniformBuffer, settings, "const VkDescriptorAddressInfoEXT*", "pUniformBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorAddressInfoEXT); + } + dump_separate_members(settings); + if (ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER) { + dump_pointer(object.pStorageBuffer, settings, "const VkDescriptorAddressInfoEXT*", "pStorageBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorAddressInfoEXT); + } + dump_separate_members(settings); + if (ApiDumpInstance::current().getDescriptorType() == VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR) { + dump_type_hex(object.accelerationStructure, settings, "VkDeviceAddress", "accelerationStructure", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDescriptorGetInfoEXT(const VkDescriptorGetInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + ApiDumpInstance::current().setDescriptorType(object.type); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDescriptorType(object.type, settings, "VkDescriptorType", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDescriptorDataEXT(object.data, settings, "VkDescriptorDataEXT", "data", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBufferCaptureDescriptorDataInfoEXT(const VkBufferCaptureDescriptorDataInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBuffer(object.buffer, settings, "VkBuffer", "buffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImageCaptureDescriptorDataInfoEXT(const VkImageCaptureDescriptorDataInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImage(object.image, settings, "VkImage", "image", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImageViewCaptureDescriptorDataInfoEXT(const VkImageViewCaptureDescriptorDataInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageView(object.imageView, settings, "VkImageView", "imageView", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSamplerCaptureDescriptorDataInfoEXT(const VkSamplerCaptureDescriptorDataInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSampler(object.sampler, settings, "VkSampler", "sampler", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkOpaqueCaptureDescriptorDataCreateInfoEXT(const VkOpaqueCaptureDescriptorDataCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.opaqueCaptureDescriptorData, settings, "const void*", "opaqueCaptureDescriptorData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAccelerationStructureCaptureDescriptorDataInfoEXT(const VkAccelerationStructureCaptureDescriptorDataInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccelerationStructureKHR(object.accelerationStructure, settings, "VkAccelerationStructureKHR", "accelerationStructure", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccelerationStructureNV(object.accelerationStructureNV, settings, "VkAccelerationStructureNV", "accelerationStructureNV", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.graphicsPipelineLibrary, settings, "VkBool32", "graphicsPipelineLibrary", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.graphicsPipelineLibraryFastLinking, settings, "VkBool32", "graphicsPipelineLibraryFastLinking", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.graphicsPipelineLibraryIndependentInterpolationDecoration, settings, "VkBool32", "graphicsPipelineLibraryIndependentInterpolationDecoration", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkGraphicsPipelineLibraryCreateInfoEXT(const VkGraphicsPipelineLibraryCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkGraphicsPipelineLibraryFlagsEXT(object.flags, settings, "VkGraphicsPipelineLibraryFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderEarlyAndLateFragmentTests, settings, "VkBool32", "shaderEarlyAndLateFragmentTests", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.fragmentShadingRateEnums, settings, "VkBool32", "fragmentShadingRateEnums", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.supersampleFragmentShadingRates, settings, "VkBool32", "supersampleFragmentShadingRates", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.noInvocationFragmentShadingRates, settings, "VkBool32", "noInvocationFragmentShadingRates", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSampleCountFlagBits(object.maxFragmentShadingRateInvocationCount, settings, "VkSampleCountFlagBits", "maxFragmentShadingRateInvocationCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(const VkPipelineFragmentShadingRateEnumStateCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFragmentShadingRateTypeNV(object.shadingRateType, settings, "VkFragmentShadingRateTypeNV", "shadingRateType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFragmentShadingRateNV(object.shadingRate, settings, "VkFragmentShadingRateNV", "shadingRate", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.combinerOps, 2, settings, "VkFragmentShadingRateCombinerOpKHR[2]", "combinerOps", "VkFragmentShadingRateCombinerOpKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkFragmentShadingRateCombinerOpKHR); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDeviceOrHostAddressConstKHR(const VkDeviceOrHostAddressConstKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_union, type_name, var_name, indents, address); + dump_type_hex(object.deviceAddress, settings, "VkDeviceAddress", "deviceAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.hostAddress, settings, "const void*", "hostAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAccelerationStructureGeometryMotionTrianglesDataNV(const VkAccelerationStructureGeometryMotionTrianglesDataNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceOrHostAddressConstKHR(object.vertexData, settings, "VkDeviceOrHostAddressConstKHR", "vertexData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAccelerationStructureMotionInfoNV(const VkAccelerationStructureMotionInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxInstances, settings, "uint32_t", "maxInstances", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccelerationStructureMotionInfoFlagsNV(object.flags, settings, "VkAccelerationStructureMotionInfoFlagsNV", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAccelerationStructureMatrixMotionInstanceNV(const VkAccelerationStructureMatrixMotionInstanceNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkTransformMatrixKHR(object.transformT0, settings, "VkTransformMatrixKHR", "transformT0", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkTransformMatrixKHR(object.transformT1, settings, "VkTransformMatrixKHR", "transformT1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.instanceCustomIndex, settings, "uint32_t:24", "instanceCustomIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.mask, settings, "uint32_t:8", "mask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.instanceShaderBindingTableRecordOffset, settings, "uint32_t:24", "instanceShaderBindingTableRecordOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkGeometryInstanceFlagsKHR(object.flags, settings, "VkGeometryInstanceFlagsKHR:8", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.accelerationStructureReference, settings, "uint64_t", "accelerationStructureReference", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSRTDataNV(const VkSRTDataNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.sx, settings, "float", "sx", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.a, settings, "float", "a", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.b, settings, "float", "b", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pvx, settings, "float", "pvx", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sy, settings, "float", "sy", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.c, settings, "float", "c", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pvy, settings, "float", "pvy", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sz, settings, "float", "sz", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pvz, settings, "float", "pvz", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.qx, settings, "float", "qx", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.qy, settings, "float", "qy", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.qz, settings, "float", "qz", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.qw, settings, "float", "qw", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tx, settings, "float", "tx", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.ty, settings, "float", "ty", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tz, settings, "float", "tz", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAccelerationStructureSRTMotionInstanceNV(const VkAccelerationStructureSRTMotionInstanceNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkSRTDataNV(object.transformT0, settings, "VkSRTDataNV", "transformT0", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSRTDataNV(object.transformT1, settings, "VkSRTDataNV", "transformT1", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.instanceCustomIndex, settings, "uint32_t:24", "instanceCustomIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.mask, settings, "uint32_t:8", "mask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.instanceShaderBindingTableRecordOffset, settings, "uint32_t:24", "instanceShaderBindingTableRecordOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkGeometryInstanceFlagsKHR(object.flags, settings, "VkGeometryInstanceFlagsKHR:8", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.accelerationStructureReference, settings, "uint64_t", "accelerationStructureReference", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAccelerationStructureMotionInstanceDataNV(const VkAccelerationStructureMotionInstanceDataNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_union, type_name, var_name, indents, address); + dump_VkAccelerationStructureInstanceKHR(object.staticInstance, settings, "VkAccelerationStructureInstanceKHR", "staticInstance", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccelerationStructureMatrixMotionInstanceNV(object.matrixMotionInstance, settings, "VkAccelerationStructureMatrixMotionInstanceNV", "matrixMotionInstance", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccelerationStructureSRTMotionInstanceNV(object.srtMotionInstance, settings, "VkAccelerationStructureSRTMotionInstanceNV", "srtMotionInstance", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAccelerationStructureMotionInstanceNV(const VkAccelerationStructureMotionInstanceNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkAccelerationStructureMotionInstanceTypeNV(object.type, settings, "VkAccelerationStructureMotionInstanceTypeNV", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccelerationStructureMotionInstanceFlagsNV(object.flags, settings, "VkAccelerationStructureMotionInstanceFlagsNV", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccelerationStructureMotionInstanceDataNV(object.data, settings, "VkAccelerationStructureMotionInstanceDataNV", "data", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.rayTracingMotionBlur, settings, "VkBool32", "rayTracingMotionBlur", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.rayTracingMotionBlurPipelineTraceRaysIndirect, settings, "VkBool32", "rayTracingMotionBlurPipelineTraceRaysIndirect", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.ycbcr2plane444Formats, settings, "VkBool32", "ycbcr2plane444Formats", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.fragmentDensityMapDeferred, settings, "VkBool32", "fragmentDensityMapDeferred", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.subsampledLoads, settings, "VkBool32", "subsampledLoads", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.subsampledCoarseReconstructionEarlyAccess, settings, "VkBool32", "subsampledCoarseReconstructionEarlyAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxSubsampledArrayLayers, settings, "uint32_t", "maxSubsampledArrayLayers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDescriptorSetSubsampledSamplers, settings, "uint32_t", "maxDescriptorSetSubsampledSamplers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCopyCommandTransformInfoQCOM(const VkCopyCommandTransformInfoQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSurfaceTransformFlagBitsKHR(object.transform, settings, "VkSurfaceTransformFlagBitsKHR", "transform", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceImageCompressionControlFeaturesEXT(const VkPhysicalDeviceImageCompressionControlFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.imageCompressionControl, settings, "VkBool32", "imageCompressionControl", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImageCompressionControlEXT(const VkImageCompressionControlEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageCompressionFlagsEXT(object.flags, settings, "VkImageCompressionFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.compressionControlPlaneCount, settings, "uint32_t", "compressionControlPlaneCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pFixedRateFlags, object.compressionControlPlaneCount, settings, "VkImageCompressionFixedRateFlagsEXT*", "pFixedRateFlags", "VkImageCompressionFixedRateFlagsEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkImageCompressionFixedRateFlagsEXT); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImageCompressionPropertiesEXT(const VkImageCompressionPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageCompressionFlagsEXT(object.imageCompressionFlags, settings, "VkImageCompressionFlagsEXT", "imageCompressionFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageCompressionFixedRateFlagsEXT(object.imageCompressionFixedRateFlags, settings, "VkImageCompressionFixedRateFlagsEXT", "imageCompressionFixedRateFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.attachmentFeedbackLoopLayout, settings, "VkBool32", "attachmentFeedbackLoopLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDevice4444FormatsFeaturesEXT(const VkPhysicalDevice4444FormatsFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.formatA4R4G4B4, settings, "VkBool32", "formatA4R4G4B4", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.formatA4B4G4R4, settings, "VkBool32", "formatA4B4G4R4", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceFaultFeaturesEXT(const VkPhysicalDeviceFaultFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.deviceFault, settings, "VkBool32", "deviceFault", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.deviceFaultVendorBinary, settings, "VkBool32", "deviceFaultVendorBinary", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDeviceFaultCountsEXT(const VkDeviceFaultCountsEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.addressInfoCount, settings, "uint32_t", "addressInfoCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vendorInfoCount, settings, "uint32_t", "vendorInfoCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vendorBinarySize, settings, "VkDeviceSize", "vendorBinarySize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDeviceFaultAddressInfoEXT(const VkDeviceFaultAddressInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkDeviceFaultAddressTypeEXT(object.addressType, settings, "VkDeviceFaultAddressTypeEXT", "addressType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type_hex(object.reportedAddress, settings, "VkDeviceAddress", "reportedAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.addressPrecision, settings, "VkDeviceSize", "addressPrecision", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDeviceFaultVendorInfoEXT(const VkDeviceFaultVendorInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_char(object.description, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "description", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vendorFaultCode, settings, "uint64_t", "vendorFaultCode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vendorFaultData, settings, "uint64_t", "vendorFaultData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDeviceFaultInfoEXT(const VkDeviceFaultInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_char(object.description, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "description", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pAddressInfos, settings, "VkDeviceFaultAddressInfoEXT*", "pAddressInfos", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDeviceFaultAddressInfoEXT); + dump_separate_members(settings); + dump_pointer(object.pVendorInfos, settings, "VkDeviceFaultVendorInfoEXT*", "pVendorInfos", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDeviceFaultVendorInfoEXT); + dump_separate_members(settings); + dump_type(object.pVendorBinaryData, settings, "void*", "pVendorBinaryData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDeviceFaultVendorBinaryHeaderVersionOneEXT(const VkDeviceFaultVendorBinaryHeaderVersionOneEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.headerSize, settings, "uint32_t", "headerSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceFaultVendorBinaryHeaderVersionEXT(object.headerVersion, settings, "VkDeviceFaultVendorBinaryHeaderVersionEXT", "headerVersion", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vendorID, settings, "uint32_t", "vendorID", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.deviceID, settings, "uint32_t", "deviceID", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.driverVersion, settings, "uint32_t", "driverVersion", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.pipelineCacheUUID, VK_UUID_SIZE, settings, "uint8_t[VK_UUID_SIZE]", "pipelineCacheUUID", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.applicationNameOffset, settings, "uint32_t", "applicationNameOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.applicationVersion, settings, "uint32_t", "applicationVersion", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.engineNameOffset, settings, "uint32_t", "engineNameOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.engineVersion, settings, "uint32_t", "engineVersion", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_api_version(object.apiVersion, settings, "uint32_t", "apiVersion", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.rasterizationOrderColorAttachmentAccess, settings, "VkBool32", "rasterizationOrderColorAttachmentAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.rasterizationOrderDepthAttachmentAccess, settings, "VkBool32", "rasterizationOrderDepthAttachmentAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.rasterizationOrderStencilAttachmentAccess, settings, "VkBool32", "rasterizationOrderStencilAttachmentAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.formatRgba10x6WithoutYCbCrSampler, settings, "VkBool32", "formatRgba10x6WithoutYCbCrSampler", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#if defined(VK_USE_PLATFORM_DIRECTFB_EXT) +template +void dump_VkDirectFBSurfaceCreateInfoEXT(const VkDirectFBSurfaceCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDirectFBSurfaceCreateFlagsEXT(object.flags, settings, "VkDirectFBSurfaceCreateFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dfb, settings, "IDirectFB*", "dfb", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.surface, settings, "IDirectFBSurface*", "surface", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#endif // VK_USE_PLATFORM_DIRECTFB_EXT +template +void dump_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.mutableDescriptorType, settings, "VkBool32", "mutableDescriptorType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMutableDescriptorTypeListEXT(const VkMutableDescriptorTypeListEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.descriptorTypeCount, settings, "uint32_t", "descriptorTypeCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pDescriptorTypes, object.descriptorTypeCount, settings, "const VkDescriptorType*", "pDescriptorTypes", "const VkDescriptorType", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorType); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMutableDescriptorTypeCreateInfoEXT(const VkMutableDescriptorTypeCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.mutableDescriptorTypeListCount, settings, "uint32_t", "mutableDescriptorTypeListCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pMutableDescriptorTypeLists, object.mutableDescriptorTypeListCount, settings, "const VkMutableDescriptorTypeListEXT*", "pMutableDescriptorTypeLists", "const VkMutableDescriptorTypeListEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkMutableDescriptorTypeListEXT); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vertexInputDynamicState, settings, "VkBool32", "vertexInputDynamicState", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVertexInputBindingDescription2EXT(const VkVertexInputBindingDescription2EXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.binding, settings, "uint32_t", "binding", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.stride, settings, "uint32_t", "stride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVertexInputRate(object.inputRate, settings, "VkVertexInputRate", "inputRate", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.divisor, settings, "uint32_t", "divisor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVertexInputAttributeDescription2EXT(const VkVertexInputAttributeDescription2EXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.location, settings, "uint32_t", "location", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.binding, settings, "uint32_t", "binding", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormat(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.offset, settings, "uint32_t", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceDrmPropertiesEXT(const VkPhysicalDeviceDrmPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.hasPrimary, settings, "VkBool32", "hasPrimary", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.hasRender, settings, "VkBool32", "hasRender", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.primaryMajor, settings, "int64_t", "primaryMajor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.primaryMinor, settings, "int64_t", "primaryMinor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.renderMajor, settings, "int64_t", "renderMajor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.renderMinor, settings, "int64_t", "renderMinor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceAddressBindingReportFeaturesEXT(const VkPhysicalDeviceAddressBindingReportFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reportAddressBinding, settings, "VkBool32", "reportAddressBinding", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDeviceAddressBindingCallbackDataEXT(const VkDeviceAddressBindingCallbackDataEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceAddressBindingFlagsEXT(object.flags, settings, "VkDeviceAddressBindingFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type_hex(object.baseAddress, settings, "VkDeviceAddress", "baseAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceAddressBindingTypeEXT(object.bindingType, settings, "VkDeviceAddressBindingTypeEXT", "bindingType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceDepthClipControlFeaturesEXT(const VkPhysicalDeviceDepthClipControlFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.depthClipControl, settings, "VkBool32", "depthClipControl", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineViewportDepthClipControlCreateInfoEXT(const VkPipelineViewportDepthClipControlCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.negativeOneToOne, settings, "VkBool32", "negativeOneToOne", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.primitiveTopologyListRestart, settings, "VkBool32", "primitiveTopologyListRestart", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.primitiveTopologyPatchListRestart, settings, "VkBool32", "primitiveTopologyPatchListRestart", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#if defined(VK_USE_PLATFORM_FUCHSIA) +template +void dump_VkImportMemoryZirconHandleInfoFUCHSIA(const VkImportMemoryZirconHandleInfoFUCHSIA& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalMemoryHandleTypeFlagBits(object.handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.handle, settings, "zx_handle_t", "handle", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMemoryZirconHandlePropertiesFUCHSIA(const VkMemoryZirconHandlePropertiesFUCHSIA& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.memoryTypeBits, settings, "uint32_t", "memoryTypeBits", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMemoryGetZirconHandleInfoFUCHSIA(const VkMemoryGetZirconHandleInfoFUCHSIA& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceMemory(object.memory, settings, "VkDeviceMemory", "memory", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalMemoryHandleTypeFlagBits(object.handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImportSemaphoreZirconHandleInfoFUCHSIA(const VkImportSemaphoreZirconHandleInfoFUCHSIA& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSemaphore(object.semaphore, settings, "VkSemaphore", "semaphore", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSemaphoreImportFlags(object.flags, settings, "VkSemaphoreImportFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalSemaphoreHandleTypeFlagBits(object.handleType, settings, "VkExternalSemaphoreHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.zirconHandle, settings, "zx_handle_t", "zirconHandle", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSemaphoreGetZirconHandleInfoFUCHSIA(const VkSemaphoreGetZirconHandleInfoFUCHSIA& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSemaphore(object.semaphore, settings, "VkSemaphore", "semaphore", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalSemaphoreHandleTypeFlagBits(object.handleType, settings, "VkExternalSemaphoreHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBufferCollectionCreateInfoFUCHSIA(const VkBufferCollectionCreateInfoFUCHSIA& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.collectionToken, settings, "zx_handle_t", "collectionToken", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImportMemoryBufferCollectionFUCHSIA(const VkImportMemoryBufferCollectionFUCHSIA& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBufferCollectionFUCHSIA(object.collection, settings, "VkBufferCollectionFUCHSIA", "collection", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.index, settings, "uint32_t", "index", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBufferCollectionImageCreateInfoFUCHSIA(const VkBufferCollectionImageCreateInfoFUCHSIA& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBufferCollectionFUCHSIA(object.collection, settings, "VkBufferCollectionFUCHSIA", "collection", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.index, settings, "uint32_t", "index", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBufferCollectionConstraintsInfoFUCHSIA(const VkBufferCollectionConstraintsInfoFUCHSIA& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minBufferCount, settings, "uint32_t", "minBufferCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxBufferCount, settings, "uint32_t", "maxBufferCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minBufferCountForCamping, settings, "uint32_t", "minBufferCountForCamping", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minBufferCountForDedicatedSlack, settings, "uint32_t", "minBufferCountForDedicatedSlack", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minBufferCountForSharedSlack, settings, "uint32_t", "minBufferCountForSharedSlack", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBufferConstraintsInfoFUCHSIA(const VkBufferConstraintsInfoFUCHSIA& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBufferCreateInfo(object.createInfo, settings, "VkBufferCreateInfo", "createInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormatFeatureFlags(object.requiredFormatFeatures, settings, "VkFormatFeatureFlags", "requiredFormatFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBufferCollectionConstraintsInfoFUCHSIA(object.bufferCollectionConstraints, settings, "VkBufferCollectionConstraintsInfoFUCHSIA", "bufferCollectionConstraints", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBufferCollectionBufferCreateInfoFUCHSIA(const VkBufferCollectionBufferCreateInfoFUCHSIA& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBufferCollectionFUCHSIA(object.collection, settings, "VkBufferCollectionFUCHSIA", "collection", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.index, settings, "uint32_t", "index", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSysmemColorSpaceFUCHSIA(const VkSysmemColorSpaceFUCHSIA& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.colorSpace, settings, "uint32_t", "colorSpace", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBufferCollectionPropertiesFUCHSIA(const VkBufferCollectionPropertiesFUCHSIA& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.memoryTypeBits, settings, "uint32_t", "memoryTypeBits", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bufferCount, settings, "uint32_t", "bufferCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.createInfoIndex, settings, "uint32_t", "createInfoIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sysmemPixelFormat, settings, "uint64_t", "sysmemPixelFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormatFeatureFlags(object.formatFeatures, settings, "VkFormatFeatureFlags", "formatFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSysmemColorSpaceFUCHSIA(object.sysmemColorSpaceIndex, settings, "VkSysmemColorSpaceFUCHSIA", "sysmemColorSpaceIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkComponentMapping(object.samplerYcbcrConversionComponents, settings, "VkComponentMapping", "samplerYcbcrConversionComponents", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSamplerYcbcrModelConversion(object.suggestedYcbcrModel, settings, "VkSamplerYcbcrModelConversion", "suggestedYcbcrModel", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSamplerYcbcrRange(object.suggestedYcbcrRange, settings, "VkSamplerYcbcrRange", "suggestedYcbcrRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkChromaLocation(object.suggestedXChromaOffset, settings, "VkChromaLocation", "suggestedXChromaOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkChromaLocation(object.suggestedYChromaOffset, settings, "VkChromaLocation", "suggestedYChromaOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImageFormatConstraintsInfoFUCHSIA(const VkImageFormatConstraintsInfoFUCHSIA& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageCreateInfo(object.imageCreateInfo, settings, "VkImageCreateInfo", "imageCreateInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormatFeatureFlags(object.requiredFormatFeatures, settings, "VkFormatFeatureFlags", "requiredFormatFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageFormatConstraintsFlagsFUCHSIA(object.flags, settings, "VkImageFormatConstraintsFlagsFUCHSIA", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sysmemPixelFormat, settings, "uint64_t", "sysmemPixelFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.colorSpaceCount, settings, "uint32_t", "colorSpaceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pColorSpaces, object.colorSpaceCount, settings, "const VkSysmemColorSpaceFUCHSIA*", "pColorSpaces", "const VkSysmemColorSpaceFUCHSIA", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSysmemColorSpaceFUCHSIA); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImageConstraintsInfoFUCHSIA(const VkImageConstraintsInfoFUCHSIA& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.formatConstraintsCount, settings, "uint32_t", "formatConstraintsCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pFormatConstraints, object.formatConstraintsCount, settings, "const VkImageFormatConstraintsInfoFUCHSIA*", "pFormatConstraints", "const VkImageFormatConstraintsInfoFUCHSIA", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkImageFormatConstraintsInfoFUCHSIA); + dump_separate_members(settings); + dump_VkBufferCollectionConstraintsInfoFUCHSIA(object.bufferCollectionConstraints, settings, "VkBufferCollectionConstraintsInfoFUCHSIA", "bufferCollectionConstraints", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageConstraintsInfoFlagsFUCHSIA(object.flags, settings, "VkImageConstraintsInfoFlagsFUCHSIA", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#endif // VK_USE_PLATFORM_FUCHSIA +template +void dump_VkSubpassShadingPipelineCreateInfoHUAWEI(const VkSubpassShadingPipelineCreateInfoHUAWEI& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkRenderPass(object.renderPass, settings, "VkRenderPass", "renderPass", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.subpass, settings, "uint32_t", "subpass", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.subpassShading, settings, "VkBool32", "subpassShading", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxSubpassShadingWorkgroupSizeAspectRatio, settings, "uint32_t", "maxSubpassShadingWorkgroupSizeAspectRatio", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.invocationMask, settings, "VkBool32", "invocationMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMemoryGetRemoteAddressInfoNV(const VkMemoryGetRemoteAddressInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceMemory(object.memory, settings, "VkDeviceMemory", "memory", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalMemoryHandleTypeFlagBits(object.handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.externalMemoryRDMA, settings, "VkBool32", "externalMemoryRDMA", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelinePropertiesIdentifierEXT(const VkPipelinePropertiesIdentifierEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.pipelineIdentifier, VK_UUID_SIZE, settings, "uint8_t[VK_UUID_SIZE]", "pipelineIdentifier", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDevicePipelinePropertiesFeaturesEXT(const VkPhysicalDevicePipelinePropertiesFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pipelinePropertiesIdentifier, settings, "VkBool32", "pipelinePropertiesIdentifier", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceFrameBoundaryFeaturesEXT(const VkPhysicalDeviceFrameBoundaryFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.frameBoundary, settings, "VkBool32", "frameBoundary", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkFrameBoundaryEXT(const VkFrameBoundaryEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFrameBoundaryFlagsEXT(object.flags, settings, "VkFrameBoundaryFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.frameID, settings, "uint64_t", "frameID", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.imageCount, settings, "uint32_t", "imageCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pImages, object.imageCount, settings, "const VkImage*", "pImages", "const VkImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkImage); + dump_separate_members(settings); + dump_type(object.bufferCount, settings, "uint32_t", "bufferCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pBuffers, object.bufferCount, settings, "const VkBuffer*", "pBuffers", "const VkBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkBuffer); + dump_separate_members(settings); + dump_type(object.tagName, settings, "uint64_t", "tagName", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tagSize, settings, "size_t", "tagSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pTag, settings, "const void*", "pTag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.multisampledRenderToSingleSampled, settings, "VkBool32", "multisampledRenderToSingleSampled", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSubpassResolvePerformanceQueryEXT(const VkSubpassResolvePerformanceQueryEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.optimal, settings, "VkBool32", "optimal", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMultisampledRenderToSingleSampledInfoEXT(const VkMultisampledRenderToSingleSampledInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.multisampledRenderToSingleSampledEnable, settings, "VkBool32", "multisampledRenderToSingleSampledEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSampleCountFlagBits(object.rasterizationSamples, settings, "VkSampleCountFlagBits", "rasterizationSamples", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.extendedDynamicState2, settings, "VkBool32", "extendedDynamicState2", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.extendedDynamicState2LogicOp, settings, "VkBool32", "extendedDynamicState2LogicOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.extendedDynamicState2PatchControlPoints, settings, "VkBool32", "extendedDynamicState2PatchControlPoints", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#if defined(VK_USE_PLATFORM_SCREEN_QNX) +template +void dump_VkScreenSurfaceCreateInfoQNX(const VkScreenSurfaceCreateInfoQNX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkScreenSurfaceCreateFlagsQNX(object.flags, settings, "VkScreenSurfaceCreateFlagsQNX", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.context, settings, "struct _screen_context*", "context", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.window, settings, "struct _screen_window*", "window", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#endif // VK_USE_PLATFORM_SCREEN_QNX +template +void dump_VkPhysicalDeviceColorWriteEnableFeaturesEXT(const VkPhysicalDeviceColorWriteEnableFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.colorWriteEnable, settings, "VkBool32", "colorWriteEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineColorWriteCreateInfoEXT(const VkPipelineColorWriteCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.attachmentCount, settings, "uint32_t", "attachmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pColorWriteEnables, object.attachmentCount, settings, "const VkBool32*", "pColorWriteEnables", "const VkBool32", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.primitivesGeneratedQuery, settings, "VkBool32", "primitivesGeneratedQuery", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.primitivesGeneratedQueryWithRasterizerDiscard, settings, "VkBool32", "primitivesGeneratedQueryWithRasterizerDiscard", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.primitivesGeneratedQueryWithNonZeroStreams, settings, "VkBool32", "primitivesGeneratedQueryWithNonZeroStreams", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE(const VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.videoEncodeRgbConversion, settings, "VkBool32", "videoEncodeRgbConversion", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeRgbConversionCapabilitiesVALVE(const VkVideoEncodeRgbConversionCapabilitiesVALVE& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeRgbModelConversionFlagsVALVE(object.rgbModels, settings, "VkVideoEncodeRgbModelConversionFlagsVALVE", "rgbModels", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeRgbRangeCompressionFlagsVALVE(object.rgbRanges, settings, "VkVideoEncodeRgbRangeCompressionFlagsVALVE", "rgbRanges", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeRgbChromaOffsetFlagsVALVE(object.xChromaOffsets, settings, "VkVideoEncodeRgbChromaOffsetFlagsVALVE", "xChromaOffsets", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeRgbChromaOffsetFlagsVALVE(object.yChromaOffsets, settings, "VkVideoEncodeRgbChromaOffsetFlagsVALVE", "yChromaOffsets", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeProfileRgbConversionInfoVALVE(const VkVideoEncodeProfileRgbConversionInfoVALVE& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.performEncodeRgbConversion, settings, "VkBool32", "performEncodeRgbConversion", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkVideoEncodeSessionRgbConversionCreateInfoVALVE(const VkVideoEncodeSessionRgbConversionCreateInfoVALVE& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeRgbModelConversionFlagBitsVALVE(object.rgbModel, settings, "VkVideoEncodeRgbModelConversionFlagBitsVALVE", "rgbModel", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeRgbRangeCompressionFlagBitsVALVE(object.rgbRange, settings, "VkVideoEncodeRgbRangeCompressionFlagBitsVALVE", "rgbRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeRgbChromaOffsetFlagBitsVALVE(object.xChromaOffset, settings, "VkVideoEncodeRgbChromaOffsetFlagBitsVALVE", "xChromaOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkVideoEncodeRgbChromaOffsetFlagBitsVALVE(object.yChromaOffset, settings, "VkVideoEncodeRgbChromaOffsetFlagBitsVALVE", "yChromaOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceImageViewMinLodFeaturesEXT(const VkPhysicalDeviceImageViewMinLodFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minLod, settings, "VkBool32", "minLod", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImageViewMinLodCreateInfoEXT(const VkImageViewMinLodCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minLod, settings, "float", "minLod", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceMultiDrawFeaturesEXT(const VkPhysicalDeviceMultiDrawFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.multiDraw, settings, "VkBool32", "multiDraw", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceMultiDrawPropertiesEXT(const VkPhysicalDeviceMultiDrawPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxMultiDrawCount, settings, "uint32_t", "maxMultiDrawCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMultiDrawInfoEXT(const VkMultiDrawInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.firstVertex, settings, "uint32_t", "firstVertex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vertexCount, settings, "uint32_t", "vertexCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMultiDrawIndexedInfoEXT(const VkMultiDrawIndexedInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.firstIndex, settings, "uint32_t", "firstIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.indexCount, settings, "uint32_t", "indexCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vertexOffset, settings, "int32_t", "vertexOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.image2DViewOf3D, settings, "VkBool32", "image2DViewOf3D", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sampler2DViewOf3D, settings, "VkBool32", "sampler2DViewOf3D", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderTileImageFeaturesEXT(const VkPhysicalDeviceShaderTileImageFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderTileImageColorReadAccess, settings, "VkBool32", "shaderTileImageColorReadAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderTileImageDepthReadAccess, settings, "VkBool32", "shaderTileImageDepthReadAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderTileImageStencilReadAccess, settings, "VkBool32", "shaderTileImageStencilReadAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderTileImagePropertiesEXT(const VkPhysicalDeviceShaderTileImagePropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderTileImageCoherentReadAccelerated, settings, "VkBool32", "shaderTileImageCoherentReadAccelerated", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderTileImageReadSampleFromPixelRateInvocation, settings, "VkBool32", "shaderTileImageReadSampleFromPixelRateInvocation", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderTileImageReadFromHelperInvocation, settings, "VkBool32", "shaderTileImageReadFromHelperInvocation", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMicromapUsageEXT(const VkMicromapUsageEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.count, settings, "uint32_t", "count", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.subdivisionLevel, settings, "uint32_t", "subdivisionLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.format, settings, "uint32_t", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDeviceOrHostAddressKHR(const VkDeviceOrHostAddressKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_union, type_name, var_name, indents, address); + dump_type_hex(object.deviceAddress, settings, "VkDeviceAddress", "deviceAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.hostAddress, settings, "void*", "hostAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMicromapBuildInfoEXT(const VkMicromapBuildInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkMicromapTypeEXT(object.type, settings, "VkMicromapTypeEXT", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBuildMicromapFlagsEXT(object.flags, settings, "VkBuildMicromapFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBuildMicromapModeEXT(object.mode, settings, "VkBuildMicromapModeEXT", "mode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkMicromapEXT(object.dstMicromap, settings, "VkMicromapEXT", "dstMicromap", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.usageCountsCount, settings, "uint32_t", "usageCountsCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pUsageCounts, object.usageCountsCount, settings, "const VkMicromapUsageEXT*", "pUsageCounts", "const VkMicromapUsageEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkMicromapUsageEXT); + dump_separate_members(settings); + dump_double_pointer_array(object.ppUsageCounts, object.usageCountsCount * 1, settings, "const VkMicromapUsageEXT* const*", "ppUsageCounts", "const VkMicromapUsageEXT*", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkMicromapUsageEXT); + dump_separate_members(settings); + dump_VkDeviceOrHostAddressConstKHR(object.data, settings, "VkDeviceOrHostAddressConstKHR", "data", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceOrHostAddressKHR(object.scratchData, settings, "VkDeviceOrHostAddressKHR", "scratchData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceOrHostAddressConstKHR(object.triangleArray, settings, "VkDeviceOrHostAddressConstKHR", "triangleArray", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.triangleArrayStride, settings, "VkDeviceSize", "triangleArrayStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMicromapCreateInfoEXT(const VkMicromapCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkMicromapCreateFlagsEXT(object.createFlags, settings, "VkMicromapCreateFlagsEXT", "createFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBuffer(object.buffer, settings, "VkBuffer", "buffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.offset, settings, "VkDeviceSize", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkMicromapTypeEXT(object.type, settings, "VkMicromapTypeEXT", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type_hex(object.deviceAddress, settings, "VkDeviceAddress", "deviceAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceOpacityMicromapFeaturesEXT(const VkPhysicalDeviceOpacityMicromapFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.micromap, settings, "VkBool32", "micromap", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.micromapCaptureReplay, settings, "VkBool32", "micromapCaptureReplay", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.micromapHostCommands, settings, "VkBool32", "micromapHostCommands", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceOpacityMicromapPropertiesEXT(const VkPhysicalDeviceOpacityMicromapPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxOpacity2StateSubdivisionLevel, settings, "uint32_t", "maxOpacity2StateSubdivisionLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxOpacity4StateSubdivisionLevel, settings, "uint32_t", "maxOpacity4StateSubdivisionLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMicromapVersionInfoEXT(const VkMicromapVersionInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pVersionData, 2 * VK_UUID_SIZE, settings, "const uint8_t*", "pVersionData", "const uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCopyMicromapToMemoryInfoEXT(const VkCopyMicromapToMemoryInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkMicromapEXT(object.src, settings, "VkMicromapEXT", "src", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceOrHostAddressKHR(object.dst, settings, "VkDeviceOrHostAddressKHR", "dst", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkCopyMicromapModeEXT(object.mode, settings, "VkCopyMicromapModeEXT", "mode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCopyMemoryToMicromapInfoEXT(const VkCopyMemoryToMicromapInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceOrHostAddressConstKHR(object.src, settings, "VkDeviceOrHostAddressConstKHR", "src", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkMicromapEXT(object.dst, settings, "VkMicromapEXT", "dst", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkCopyMicromapModeEXT(object.mode, settings, "VkCopyMicromapModeEXT", "mode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCopyMicromapInfoEXT(const VkCopyMicromapInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkMicromapEXT(object.src, settings, "VkMicromapEXT", "src", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkMicromapEXT(object.dst, settings, "VkMicromapEXT", "dst", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkCopyMicromapModeEXT(object.mode, settings, "VkCopyMicromapModeEXT", "mode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMicromapBuildSizesInfoEXT(const VkMicromapBuildSizesInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.micromapSize, settings, "VkDeviceSize", "micromapSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.buildScratchSize, settings, "VkDeviceSize", "buildScratchSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.discardable, settings, "VkBool32", "discardable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAccelerationStructureTrianglesOpacityMicromapEXT(const VkAccelerationStructureTrianglesOpacityMicromapEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkIndexType(object.indexType, settings, "VkIndexType", "indexType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceOrHostAddressConstKHR(object.indexBuffer, settings, "VkDeviceOrHostAddressConstKHR", "indexBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.indexStride, settings, "VkDeviceSize", "indexStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.baseTriangle, settings, "uint32_t", "baseTriangle", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.usageCountsCount, settings, "uint32_t", "usageCountsCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pUsageCounts, object.usageCountsCount, settings, "const VkMicromapUsageEXT*", "pUsageCounts", "const VkMicromapUsageEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkMicromapUsageEXT); + dump_separate_members(settings); + dump_double_pointer_array(object.ppUsageCounts, object.usageCountsCount * 1, settings, "const VkMicromapUsageEXT* const*", "ppUsageCounts", "const VkMicromapUsageEXT*", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkMicromapUsageEXT); + dump_separate_members(settings); + dump_VkMicromapEXT(object.micromap, settings, "VkMicromapEXT", "micromap", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMicromapTriangleEXT(const VkMicromapTriangleEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.dataOffset, settings, "uint32_t", "dataOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.subdivisionLevel, settings, "uint16_t", "subdivisionLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.format, settings, "uint16_t", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +#if defined(VK_ENABLE_BETA_EXTENSIONS) +template +void dump_VkPhysicalDeviceDisplacementMicromapFeaturesNV(const VkPhysicalDeviceDisplacementMicromapFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.displacementMicromap, settings, "VkBool32", "displacementMicromap", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceDisplacementMicromapPropertiesNV(const VkPhysicalDeviceDisplacementMicromapPropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDisplacementMicromapSubdivisionLevel, settings, "uint32_t", "maxDisplacementMicromapSubdivisionLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAccelerationStructureTrianglesDisplacementMicromapNV(const VkAccelerationStructureTrianglesDisplacementMicromapNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormat(object.displacementBiasAndScaleFormat, settings, "VkFormat", "displacementBiasAndScaleFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormat(object.displacementVectorFormat, settings, "VkFormat", "displacementVectorFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceOrHostAddressConstKHR(object.displacementBiasAndScaleBuffer, settings, "VkDeviceOrHostAddressConstKHR", "displacementBiasAndScaleBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.displacementBiasAndScaleStride, settings, "VkDeviceSize", "displacementBiasAndScaleStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceOrHostAddressConstKHR(object.displacementVectorBuffer, settings, "VkDeviceOrHostAddressConstKHR", "displacementVectorBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.displacementVectorStride, settings, "VkDeviceSize", "displacementVectorStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceOrHostAddressConstKHR(object.displacedMicromapPrimitiveFlags, settings, "VkDeviceOrHostAddressConstKHR", "displacedMicromapPrimitiveFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.displacedMicromapPrimitiveFlagsStride, settings, "VkDeviceSize", "displacedMicromapPrimitiveFlagsStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkIndexType(object.indexType, settings, "VkIndexType", "indexType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceOrHostAddressConstKHR(object.indexBuffer, settings, "VkDeviceOrHostAddressConstKHR", "indexBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.indexStride, settings, "VkDeviceSize", "indexStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.baseTriangle, settings, "uint32_t", "baseTriangle", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.usageCountsCount, settings, "uint32_t", "usageCountsCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pUsageCounts, object.usageCountsCount, settings, "const VkMicromapUsageEXT*", "pUsageCounts", "const VkMicromapUsageEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkMicromapUsageEXT); + dump_separate_members(settings); + dump_double_pointer_array(object.ppUsageCounts, object.usageCountsCount * 1, settings, "const VkMicromapUsageEXT* const*", "ppUsageCounts", "const VkMicromapUsageEXT*", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkMicromapUsageEXT); + dump_separate_members(settings); + dump_VkMicromapEXT(object.micromap, settings, "VkMicromapEXT", "micromap", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#endif // VK_ENABLE_BETA_EXTENSIONS +template +void dump_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.clustercullingShader, settings, "VkBool32", "clustercullingShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.multiviewClusterCullingShader, settings, "VkBool32", "multiviewClusterCullingShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.maxWorkGroupCount, 3, settings, "uint32_t[3]", "maxWorkGroupCount", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_single_array(object.maxWorkGroupSize, 3, settings, "uint32_t[3]", "maxWorkGroupSize", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.maxOutputClusterCount, settings, "uint32_t", "maxOutputClusterCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.indirectBufferOffsetAlignment, settings, "VkDeviceSize", "indirectBufferOffsetAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI(const VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.clusterShadingRate, settings, "VkBool32", "clusterShadingRate", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.borderColorSwizzle, settings, "VkBool32", "borderColorSwizzle", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.borderColorSwizzleFromImage, settings, "VkBool32", "borderColorSwizzleFromImage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSamplerBorderColorComponentMappingCreateInfoEXT(const VkSamplerBorderColorComponentMappingCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkComponentMapping(object.components, settings, "VkComponentMapping", "components", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.srgb, settings, "VkBool32", "srgb", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pageableDeviceLocalMemory, settings, "VkBool32", "pageableDeviceLocalMemory", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderCorePropertiesARM(const VkPhysicalDeviceShaderCorePropertiesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pixelRate, settings, "uint32_t", "pixelRate", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.texelRate, settings, "uint32_t", "texelRate", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.fmaRate, settings, "uint32_t", "fmaRate", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDeviceQueueShaderCoreControlCreateInfoARM(const VkDeviceQueueShaderCoreControlCreateInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderCoreCount, settings, "uint32_t", "shaderCoreCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceSchedulingControlsFeaturesARM(const VkPhysicalDeviceSchedulingControlsFeaturesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.schedulingControls, settings, "VkBool32", "schedulingControls", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceSchedulingControlsPropertiesARM(const VkPhysicalDeviceSchedulingControlsPropertiesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPhysicalDeviceSchedulingControlsFlagsARM(object.schedulingControlsFlags, settings, "VkPhysicalDeviceSchedulingControlsFlagsARM", "schedulingControlsFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.imageSlicedViewOf3D, settings, "VkBool32", "imageSlicedViewOf3D", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImageViewSlicedCreateInfoEXT(const VkImageViewSlicedCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sliceOffset, settings, "uint32_t", "sliceOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.sliceCount, settings, "uint32_t", "sliceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorSetHostMapping, settings, "VkBool32", "descriptorSetHostMapping", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDescriptorSetBindingReferenceVALVE(const VkDescriptorSetBindingReferenceVALVE& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDescriptorSetLayout(object.descriptorSetLayout, settings, "VkDescriptorSetLayout", "descriptorSetLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.binding, settings, "uint32_t", "binding", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDescriptorSetLayoutHostMappingInfoVALVE(const VkDescriptorSetLayoutHostMappingInfoVALVE& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorOffset, settings, "size_t", "descriptorOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorSize, settings, "uint32_t", "descriptorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.nonSeamlessCubeMap, settings, "VkBool32", "nonSeamlessCubeMap", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceRenderPassStripedFeaturesARM(const VkPhysicalDeviceRenderPassStripedFeaturesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.renderPassStriped, settings, "VkBool32", "renderPassStriped", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceRenderPassStripedPropertiesARM(const VkPhysicalDeviceRenderPassStripedPropertiesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.renderPassStripeGranularity, settings, "VkExtent2D", "renderPassStripeGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxRenderPassStripes, settings, "uint32_t", "maxRenderPassStripes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkRenderPassStripeInfoARM(const VkRenderPassStripeInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkRect2D(object.stripeArea, settings, "VkRect2D", "stripeArea", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkRenderPassStripeBeginInfoARM(const VkRenderPassStripeBeginInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.stripeInfoCount, settings, "uint32_t", "stripeInfoCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pStripeInfos, object.stripeInfoCount, settings, "const VkRenderPassStripeInfoARM*", "pStripeInfos", "const VkRenderPassStripeInfoARM", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkRenderPassStripeInfoARM); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkRenderPassStripeSubmitInfoARM(const VkRenderPassStripeSubmitInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.stripeSemaphoreInfoCount, settings, "uint32_t", "stripeSemaphoreInfoCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pStripeSemaphoreInfos, object.stripeSemaphoreInfoCount, settings, "const VkSemaphoreSubmitInfo*", "pStripeSemaphoreInfos", "const VkSemaphoreSubmitInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSemaphoreSubmitInfo); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT(const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.fragmentDensityMapOffset, settings, "VkBool32", "fragmentDensityMapOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT(const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.fragmentDensityOffsetGranularity, settings, "VkExtent2D", "fragmentDensityOffsetGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkRenderPassFragmentDensityMapOffsetEndInfoEXT(const VkRenderPassFragmentDensityMapOffsetEndInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.fragmentDensityOffsetCount, settings, "uint32_t", "fragmentDensityOffsetCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pFragmentDensityOffsets, object.fragmentDensityOffsetCount, settings, "const VkOffset2D*", "pFragmentDensityOffsets", "const VkOffset2D", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkOffset2D); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.indirectCopy, settings, "VkBool32", "indirectCopy", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDecompressMemoryRegionNV(const VkDecompressMemoryRegionNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type_hex(object.srcAddress, settings, "VkDeviceAddress", "srcAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type_hex(object.dstAddress, settings, "VkDeviceAddress", "dstAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.compressedSize, settings, "VkDeviceSize", "compressedSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.decompressedSize, settings, "VkDeviceSize", "decompressedSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkMemoryDecompressionMethodFlagsEXT(object.decompressionMethod, settings, "VkMemoryDecompressionMethodFlagsNV", "decompressionMethod", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceMemoryDecompressionFeaturesEXT(const VkPhysicalDeviceMemoryDecompressionFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.memoryDecompression, settings, "VkBool32", "memoryDecompression", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceMemoryDecompressionPropertiesEXT(const VkPhysicalDeviceMemoryDecompressionPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkMemoryDecompressionMethodFlagsEXT(object.decompressionMethods, settings, "VkMemoryDecompressionMethodFlagsEXT", "decompressionMethods", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDecompressionIndirectCount, settings, "uint64_t", "maxDecompressionIndirectCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV(const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.deviceGeneratedCompute, settings, "VkBool32", "deviceGeneratedCompute", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.deviceGeneratedComputePipelines, settings, "VkBool32", "deviceGeneratedComputePipelines", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.deviceGeneratedComputeCaptureReplay, settings, "VkBool32", "deviceGeneratedComputeCaptureReplay", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkComputePipelineIndirectBufferInfoNV(const VkComputePipelineIndirectBufferInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type_hex(object.deviceAddress, settings, "VkDeviceAddress", "deviceAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type_hex(object.pipelineDeviceAddressCaptureReplay, settings, "VkDeviceAddress", "pipelineDeviceAddressCaptureReplay", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineIndirectDeviceAddressInfoNV(const VkPipelineIndirectDeviceAddressInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineBindPoint(object.pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipeline(object.pipeline, settings, "VkPipeline", "pipeline", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBindPipelineIndirectCommandNV(const VkBindPipelineIndirectCommandNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type_hex(object.pipelineAddress, settings, "VkDeviceAddress", "pipelineAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV(const VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.spheres, settings, "VkBool32", "spheres", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.linearSweptSpheres, settings, "VkBool32", "linearSweptSpheres", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAccelerationStructureGeometryLinearSweptSpheresDataNV(const VkAccelerationStructureGeometryLinearSweptSpheresDataNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormat(object.vertexFormat, settings, "VkFormat", "vertexFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceOrHostAddressConstKHR(object.vertexData, settings, "VkDeviceOrHostAddressConstKHR", "vertexData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vertexStride, settings, "VkDeviceSize", "vertexStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormat(object.radiusFormat, settings, "VkFormat", "radiusFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceOrHostAddressConstKHR(object.radiusData, settings, "VkDeviceOrHostAddressConstKHR", "radiusData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.radiusStride, settings, "VkDeviceSize", "radiusStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkIndexType(object.indexType, settings, "VkIndexType", "indexType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceOrHostAddressConstKHR(object.indexData, settings, "VkDeviceOrHostAddressConstKHR", "indexData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.indexStride, settings, "VkDeviceSize", "indexStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkRayTracingLssIndexingModeNV(object.indexingMode, settings, "VkRayTracingLssIndexingModeNV", "indexingMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkRayTracingLssPrimitiveEndCapsModeNV(object.endCapsMode, settings, "VkRayTracingLssPrimitiveEndCapsModeNV", "endCapsMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAccelerationStructureGeometrySpheresDataNV(const VkAccelerationStructureGeometrySpheresDataNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormat(object.vertexFormat, settings, "VkFormat", "vertexFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceOrHostAddressConstKHR(object.vertexData, settings, "VkDeviceOrHostAddressConstKHR", "vertexData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vertexStride, settings, "VkDeviceSize", "vertexStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormat(object.radiusFormat, settings, "VkFormat", "radiusFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceOrHostAddressConstKHR(object.radiusData, settings, "VkDeviceOrHostAddressConstKHR", "radiusData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.radiusStride, settings, "VkDeviceSize", "radiusStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkIndexType(object.indexType, settings, "VkIndexType", "indexType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceOrHostAddressConstKHR(object.indexData, settings, "VkDeviceOrHostAddressConstKHR", "indexData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.indexStride, settings, "VkDeviceSize", "indexStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(const VkPhysicalDeviceLinearColorAttachmentFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.linearColorAttachment, settings, "VkBool32", "linearColorAttachment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.imageCompressionControlSwapchain, settings, "VkBool32", "imageCompressionControlSwapchain", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImageViewSampleWeightCreateInfoQCOM(const VkImageViewSampleWeightCreateInfoQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkOffset2D(object.filterCenter, settings, "VkOffset2D", "filterCenter", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.filterSize, settings, "VkExtent2D", "filterSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.numPhases, settings, "uint32_t", "numPhases", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceImageProcessingFeaturesQCOM(const VkPhysicalDeviceImageProcessingFeaturesQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.textureSampleWeighted, settings, "VkBool32", "textureSampleWeighted", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.textureBoxFilter, settings, "VkBool32", "textureBoxFilter", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.textureBlockMatch, settings, "VkBool32", "textureBlockMatch", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceImageProcessingPropertiesQCOM(const VkPhysicalDeviceImageProcessingPropertiesQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxWeightFilterPhases, settings, "uint32_t", "maxWeightFilterPhases", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.maxWeightFilterDimension, settings, "VkExtent2D", "maxWeightFilterDimension", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.maxBlockMatchRegion, settings, "VkExtent2D", "maxBlockMatchRegion", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.maxBoxFilterBlockSize, settings, "VkExtent2D", "maxBoxFilterBlockSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceNestedCommandBufferFeaturesEXT(const VkPhysicalDeviceNestedCommandBufferFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.nestedCommandBuffer, settings, "VkBool32", "nestedCommandBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.nestedCommandBufferRendering, settings, "VkBool32", "nestedCommandBufferRendering", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.nestedCommandBufferSimultaneousUse, settings, "VkBool32", "nestedCommandBufferSimultaneousUse", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceNestedCommandBufferPropertiesEXT(const VkPhysicalDeviceNestedCommandBufferPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxCommandBufferNestingLevel, settings, "uint32_t", "maxCommandBufferNestingLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#if defined(VK_USE_PLATFORM_OHOS) +template +void dump_VkNativeBufferUsageOHOS(const VkNativeBufferUsageOHOS& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.OHOSNativeBufferUsage, settings, "uint64_t", "OHOSNativeBufferUsage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkNativeBufferPropertiesOHOS(const VkNativeBufferPropertiesOHOS& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.allocationSize, settings, "VkDeviceSize", "allocationSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.memoryTypeBits, settings, "uint32_t", "memoryTypeBits", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkNativeBufferFormatPropertiesOHOS(const VkNativeBufferFormatPropertiesOHOS& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormat(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.externalFormat, settings, "uint64_t", "externalFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormatFeatureFlags(object.formatFeatures, settings, "VkFormatFeatureFlags", "formatFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkComponentMapping(object.samplerYcbcrConversionComponents, settings, "VkComponentMapping", "samplerYcbcrConversionComponents", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSamplerYcbcrModelConversion(object.suggestedYcbcrModel, settings, "VkSamplerYcbcrModelConversion", "suggestedYcbcrModel", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSamplerYcbcrRange(object.suggestedYcbcrRange, settings, "VkSamplerYcbcrRange", "suggestedYcbcrRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkChromaLocation(object.suggestedXChromaOffset, settings, "VkChromaLocation", "suggestedXChromaOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkChromaLocation(object.suggestedYChromaOffset, settings, "VkChromaLocation", "suggestedYChromaOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImportNativeBufferInfoOHOS(const VkImportNativeBufferInfoOHOS& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.buffer, settings, "struct OH_NativeBuffer*", "buffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMemoryGetNativeBufferInfoOHOS(const VkMemoryGetNativeBufferInfoOHOS& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceMemory(object.memory, settings, "VkDeviceMemory", "memory", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkExternalFormatOHOS(const VkExternalFormatOHOS& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.externalFormat, settings, "uint64_t", "externalFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#endif // VK_USE_PLATFORM_OHOS +template +void dump_VkExternalMemoryAcquireUnmodifiedEXT(const VkExternalMemoryAcquireUnmodifiedEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.acquireUnmodifiedMemory, settings, "VkBool32", "acquireUnmodifiedMemory", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.extendedDynamicState3TessellationDomainOrigin, settings, "VkBool32", "extendedDynamicState3TessellationDomainOrigin", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.extendedDynamicState3DepthClampEnable, settings, "VkBool32", "extendedDynamicState3DepthClampEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.extendedDynamicState3PolygonMode, settings, "VkBool32", "extendedDynamicState3PolygonMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.extendedDynamicState3RasterizationSamples, settings, "VkBool32", "extendedDynamicState3RasterizationSamples", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.extendedDynamicState3SampleMask, settings, "VkBool32", "extendedDynamicState3SampleMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.extendedDynamicState3AlphaToCoverageEnable, settings, "VkBool32", "extendedDynamicState3AlphaToCoverageEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.extendedDynamicState3AlphaToOneEnable, settings, "VkBool32", "extendedDynamicState3AlphaToOneEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.extendedDynamicState3LogicOpEnable, settings, "VkBool32", "extendedDynamicState3LogicOpEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.extendedDynamicState3ColorBlendEnable, settings, "VkBool32", "extendedDynamicState3ColorBlendEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.extendedDynamicState3ColorBlendEquation, settings, "VkBool32", "extendedDynamicState3ColorBlendEquation", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.extendedDynamicState3ColorWriteMask, settings, "VkBool32", "extendedDynamicState3ColorWriteMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.extendedDynamicState3RasterizationStream, settings, "VkBool32", "extendedDynamicState3RasterizationStream", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.extendedDynamicState3ConservativeRasterizationMode, settings, "VkBool32", "extendedDynamicState3ConservativeRasterizationMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.extendedDynamicState3ExtraPrimitiveOverestimationSize, settings, "VkBool32", "extendedDynamicState3ExtraPrimitiveOverestimationSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.extendedDynamicState3DepthClipEnable, settings, "VkBool32", "extendedDynamicState3DepthClipEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.extendedDynamicState3SampleLocationsEnable, settings, "VkBool32", "extendedDynamicState3SampleLocationsEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.extendedDynamicState3ColorBlendAdvanced, settings, "VkBool32", "extendedDynamicState3ColorBlendAdvanced", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.extendedDynamicState3ProvokingVertexMode, settings, "VkBool32", "extendedDynamicState3ProvokingVertexMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.extendedDynamicState3LineRasterizationMode, settings, "VkBool32", "extendedDynamicState3LineRasterizationMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.extendedDynamicState3LineStippleEnable, settings, "VkBool32", "extendedDynamicState3LineStippleEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.extendedDynamicState3DepthClipNegativeOneToOne, settings, "VkBool32", "extendedDynamicState3DepthClipNegativeOneToOne", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.extendedDynamicState3ViewportWScalingEnable, settings, "VkBool32", "extendedDynamicState3ViewportWScalingEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.extendedDynamicState3ViewportSwizzle, settings, "VkBool32", "extendedDynamicState3ViewportSwizzle", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.extendedDynamicState3CoverageToColorEnable, settings, "VkBool32", "extendedDynamicState3CoverageToColorEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.extendedDynamicState3CoverageToColorLocation, settings, "VkBool32", "extendedDynamicState3CoverageToColorLocation", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.extendedDynamicState3CoverageModulationMode, settings, "VkBool32", "extendedDynamicState3CoverageModulationMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.extendedDynamicState3CoverageModulationTableEnable, settings, "VkBool32", "extendedDynamicState3CoverageModulationTableEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.extendedDynamicState3CoverageModulationTable, settings, "VkBool32", "extendedDynamicState3CoverageModulationTable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.extendedDynamicState3CoverageReductionMode, settings, "VkBool32", "extendedDynamicState3CoverageReductionMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.extendedDynamicState3RepresentativeFragmentTestEnable, settings, "VkBool32", "extendedDynamicState3RepresentativeFragmentTestEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.extendedDynamicState3ShadingRateImageEnable, settings, "VkBool32", "extendedDynamicState3ShadingRateImageEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dynamicPrimitiveTopologyUnrestricted, settings, "VkBool32", "dynamicPrimitiveTopologyUnrestricted", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkColorBlendEquationEXT(const VkColorBlendEquationEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkBlendFactor(object.srcColorBlendFactor, settings, "VkBlendFactor", "srcColorBlendFactor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBlendFactor(object.dstColorBlendFactor, settings, "VkBlendFactor", "dstColorBlendFactor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBlendOp(object.colorBlendOp, settings, "VkBlendOp", "colorBlendOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBlendFactor(object.srcAlphaBlendFactor, settings, "VkBlendFactor", "srcAlphaBlendFactor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBlendFactor(object.dstAlphaBlendFactor, settings, "VkBlendFactor", "dstAlphaBlendFactor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBlendOp(object.alphaBlendOp, settings, "VkBlendOp", "alphaBlendOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkColorBlendAdvancedEXT(const VkColorBlendAdvancedEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkBlendOp(object.advancedBlendOp, settings, "VkBlendOp", "advancedBlendOp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.srcPremultiplied, settings, "VkBool32", "srcPremultiplied", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dstPremultiplied, settings, "VkBool32", "dstPremultiplied", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBlendOverlapEXT(object.blendOverlap, settings, "VkBlendOverlapEXT", "blendOverlap", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.clampResults, settings, "VkBool32", "clampResults", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.subpassMergeFeedback, settings, "VkBool32", "subpassMergeFeedback", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkRenderPassCreationControlEXT(const VkRenderPassCreationControlEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.disallowMerging, settings, "VkBool32", "disallowMerging", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkRenderPassCreationFeedbackInfoEXT(const VkRenderPassCreationFeedbackInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.postMergeSubpassCount, settings, "uint32_t", "postMergeSubpassCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkRenderPassCreationFeedbackCreateInfoEXT(const VkRenderPassCreationFeedbackCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pRenderPassFeedback, settings, "VkRenderPassCreationFeedbackInfoEXT*", "pRenderPassFeedback", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkRenderPassCreationFeedbackInfoEXT); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkRenderPassSubpassFeedbackInfoEXT(const VkRenderPassSubpassFeedbackInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkSubpassMergeStatusEXT(object.subpassMergeStatus, settings, "VkSubpassMergeStatusEXT", "subpassMergeStatus", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_char(object.description, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "description", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.postMergeIndex, settings, "uint32_t", "postMergeIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkRenderPassSubpassFeedbackCreateInfoEXT(const VkRenderPassSubpassFeedbackCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pSubpassFeedback, settings, "VkRenderPassSubpassFeedbackInfoEXT*", "pSubpassFeedback", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkRenderPassSubpassFeedbackInfoEXT); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDirectDriverLoadingInfoLUNARG(const VkDirectDriverLoadingInfoLUNARG& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDirectDriverLoadingFlagsLUNARG(object.flags, settings, "VkDirectDriverLoadingFlagsLUNARG", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_PFN_vkGetInstanceProcAddrLUNARG(object.pfnGetInstanceProcAddr, settings, "PFN_vkGetInstanceProcAddrLUNARG", "pfnGetInstanceProcAddr", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDirectDriverLoadingListLUNARG(const VkDirectDriverLoadingListLUNARG& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDirectDriverLoadingModeLUNARG(object.mode, settings, "VkDirectDriverLoadingModeLUNARG", "mode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.driverCount, settings, "uint32_t", "driverCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pDrivers, object.driverCount, settings, "const VkDirectDriverLoadingInfoLUNARG*", "pDrivers", "const VkDirectDriverLoadingInfoLUNARG", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDirectDriverLoadingInfoLUNARG); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkTensorDescriptionARM(const VkTensorDescriptionARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkTensorTilingARM(object.tiling, settings, "VkTensorTilingARM", "tiling", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormat(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dimensionCount, settings, "uint32_t", "dimensionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pDimensions, object.dimensionCount, settings, "const int64_t*", "pDimensions", "const int64_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(object.pStrides, object.dimensionCount, settings, "const int64_t*", "pStrides", "const int64_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_VkTensorUsageFlagsARM(object.usage, settings, "VkTensorUsageFlagsARM", "usage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkTensorCreateInfoARM(const VkTensorCreateInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkTensorCreateFlagsARM(object.flags, settings, "VkTensorCreateFlagsARM", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pDescription, settings, "const VkTensorDescriptionARM*", "pDescription", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkTensorDescriptionARM); + dump_separate_members(settings); + dump_VkSharingMode(object.sharingMode, settings, "VkSharingMode", "sharingMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.queueFamilyIndexCount, settings, "uint32_t", "queueFamilyIndexCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pQueueFamilyIndices, object.queueFamilyIndexCount, settings, "const uint32_t*", "pQueueFamilyIndices", "const uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkTensorMemoryRequirementsInfoARM(const VkTensorMemoryRequirementsInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkTensorARM(object.tensor, settings, "VkTensorARM", "tensor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBindTensorMemoryInfoARM(const VkBindTensorMemoryInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkTensorARM(object.tensor, settings, "VkTensorARM", "tensor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceMemory(object.memory, settings, "VkDeviceMemory", "memory", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.memoryOffset, settings, "VkDeviceSize", "memoryOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkWriteDescriptorSetTensorARM(const VkWriteDescriptorSetTensorARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tensorViewCount, settings, "uint32_t", "tensorViewCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pTensorViews, object.tensorViewCount, settings, "const VkTensorViewARM*", "pTensorViews", "const VkTensorViewARM", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkTensorViewARM); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkTensorFormatPropertiesARM(const VkTensorFormatPropertiesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormatFeatureFlags2(object.optimalTilingTensorFeatures, settings, "VkFormatFeatureFlags2", "optimalTilingTensorFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormatFeatureFlags2(object.linearTilingTensorFeatures, settings, "VkFormatFeatureFlags2", "linearTilingTensorFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceTensorPropertiesARM(const VkPhysicalDeviceTensorPropertiesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxTensorDimensionCount, settings, "uint32_t", "maxTensorDimensionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxTensorElements, settings, "uint64_t", "maxTensorElements", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPerDimensionTensorElements, settings, "uint64_t", "maxPerDimensionTensorElements", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxTensorStride, settings, "int64_t", "maxTensorStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxTensorSize, settings, "uint64_t", "maxTensorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxTensorShaderAccessArrayLength, settings, "uint32_t", "maxTensorShaderAccessArrayLength", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxTensorShaderAccessSize, settings, "uint32_t", "maxTensorShaderAccessSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDescriptorSetStorageTensors, settings, "uint32_t", "maxDescriptorSetStorageTensors", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPerStageDescriptorSetStorageTensors, settings, "uint32_t", "maxPerStageDescriptorSetStorageTensors", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDescriptorSetUpdateAfterBindStorageTensors, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindStorageTensors", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPerStageDescriptorUpdateAfterBindStorageTensors, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindStorageTensors", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderStorageTensorArrayNonUniformIndexingNative, settings, "VkBool32", "shaderStorageTensorArrayNonUniformIndexingNative", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkShaderStageFlags(object.shaderTensorSupportedStages, settings, "VkShaderStageFlags", "shaderTensorSupportedStages", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkTensorMemoryBarrierARM(const VkTensorMemoryBarrierARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineStageFlags2(object.srcStageMask, settings, "VkPipelineStageFlags2", "srcStageMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccessFlags2(object.srcAccessMask, settings, "VkAccessFlags2", "srcAccessMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineStageFlags2(object.dstStageMask, settings, "VkPipelineStageFlags2", "dstStageMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccessFlags2(object.dstAccessMask, settings, "VkAccessFlags2", "dstAccessMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.srcQueueFamilyIndex, settings, "uint32_t", "srcQueueFamilyIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dstQueueFamilyIndex, settings, "uint32_t", "dstQueueFamilyIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkTensorARM(object.tensor, settings, "VkTensorARM", "tensor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkTensorDependencyInfoARM(const VkTensorDependencyInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tensorMemoryBarrierCount, settings, "uint32_t", "tensorMemoryBarrierCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pTensorMemoryBarriers, settings, "const VkTensorMemoryBarrierARM*", "pTensorMemoryBarriers", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkTensorMemoryBarrierARM); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceTensorFeaturesARM(const VkPhysicalDeviceTensorFeaturesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tensorNonPacked, settings, "VkBool32", "tensorNonPacked", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderTensorAccess, settings, "VkBool32", "shaderTensorAccess", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderStorageTensorArrayDynamicIndexing, settings, "VkBool32", "shaderStorageTensorArrayDynamicIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderStorageTensorArrayNonUniformIndexing, settings, "VkBool32", "shaderStorageTensorArrayNonUniformIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorBindingStorageTensorUpdateAfterBind, settings, "VkBool32", "descriptorBindingStorageTensorUpdateAfterBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tensors, settings, "VkBool32", "tensors", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDeviceTensorMemoryRequirementsARM(const VkDeviceTensorMemoryRequirementsARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pCreateInfo, settings, "const VkTensorCreateInfoARM*", "pCreateInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkTensorCreateInfoARM); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkTensorCopyARM(const VkTensorCopyARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dimensionCount, settings, "uint32_t", "dimensionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pSrcOffset, object.dimensionCount, settings, "const uint64_t*", "pSrcOffset", "const uint64_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(object.pDstOffset, object.dimensionCount, settings, "const uint64_t*", "pDstOffset", "const uint64_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(object.pExtent, object.dimensionCount, settings, "const uint64_t*", "pExtent", "const uint64_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCopyTensorInfoARM(const VkCopyTensorInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkTensorARM(object.srcTensor, settings, "VkTensorARM", "srcTensor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkTensorARM(object.dstTensor, settings, "VkTensorARM", "dstTensor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.regionCount, settings, "uint32_t", "regionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pRegions, object.regionCount, settings, "const VkTensorCopyARM*", "pRegions", "const VkTensorCopyARM", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkTensorCopyARM); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMemoryDedicatedAllocateInfoTensorARM(const VkMemoryDedicatedAllocateInfoTensorARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkTensorARM(object.tensor, settings, "VkTensorARM", "tensor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceExternalTensorInfoARM(const VkPhysicalDeviceExternalTensorInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkTensorCreateFlagsARM(object.flags, settings, "VkTensorCreateFlagsARM", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pDescription, settings, "const VkTensorDescriptionARM*", "pDescription", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkTensorDescriptionARM); + dump_separate_members(settings); + dump_VkExternalMemoryHandleTypeFlagBits(object.handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkExternalTensorPropertiesARM(const VkExternalTensorPropertiesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalMemoryProperties(object.externalMemoryProperties, settings, "VkExternalMemoryProperties", "externalMemoryProperties", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkExternalMemoryTensorCreateInfoARM(const VkExternalMemoryTensorCreateInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalMemoryHandleTypeFlags(object.handleTypes, settings, "VkExternalMemoryHandleTypeFlags", "handleTypes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM(const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorBufferTensorDescriptors, settings, "VkBool32", "descriptorBufferTensorDescriptors", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM(const VkPhysicalDeviceDescriptorBufferTensorPropertiesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tensorCaptureReplayDescriptorDataSize, settings, "size_t", "tensorCaptureReplayDescriptorDataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tensorViewCaptureReplayDescriptorDataSize, settings, "size_t", "tensorViewCaptureReplayDescriptorDataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tensorDescriptorSize, settings, "size_t", "tensorDescriptorSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDescriptorGetTensorInfoARM(const VkDescriptorGetTensorInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkTensorViewARM(object.tensorView, settings, "VkTensorViewARM", "tensorView", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkTensorCaptureDescriptorDataInfoARM(const VkTensorCaptureDescriptorDataInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkTensorARM(object.tensor, settings, "VkTensorARM", "tensor", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkTensorViewCaptureDescriptorDataInfoARM(const VkTensorViewCaptureDescriptorDataInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkTensorViewARM(object.tensorView, settings, "VkTensorViewARM", "tensorView", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkFrameBoundaryTensorsARM(const VkFrameBoundaryTensorsARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tensorCount, settings, "uint32_t", "tensorCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pTensors, object.tensorCount, settings, "const VkTensorARM*", "pTensors", "const VkTensorARM", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkTensorARM); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderModuleIdentifier, settings, "VkBool32", "shaderModuleIdentifier", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.shaderModuleIdentifierAlgorithmUUID, VK_UUID_SIZE, settings, "uint8_t[VK_UUID_SIZE]", "shaderModuleIdentifierAlgorithmUUID", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(const VkPipelineShaderStageModuleIdentifierCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.identifierSize, settings, "uint32_t", "identifierSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pIdentifier, object.identifierSize, settings, "const uint8_t*", "pIdentifier", "const uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkShaderModuleIdentifierEXT(const VkShaderModuleIdentifierEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.identifierSize, settings, "uint32_t", "identifierSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.identifier, std::min(object.identifierSize, VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT), settings, "uint8_t[VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT]", "identifier", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceOpticalFlowFeaturesNV(const VkPhysicalDeviceOpticalFlowFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.opticalFlow, settings, "VkBool32", "opticalFlow", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceOpticalFlowPropertiesNV(const VkPhysicalDeviceOpticalFlowPropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkOpticalFlowGridSizeFlagsNV(object.supportedOutputGridSizes, settings, "VkOpticalFlowGridSizeFlagsNV", "supportedOutputGridSizes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkOpticalFlowGridSizeFlagsNV(object.supportedHintGridSizes, settings, "VkOpticalFlowGridSizeFlagsNV", "supportedHintGridSizes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.hintSupported, settings, "VkBool32", "hintSupported", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.costSupported, settings, "VkBool32", "costSupported", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bidirectionalFlowSupported, settings, "VkBool32", "bidirectionalFlowSupported", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.globalFlowSupported, settings, "VkBool32", "globalFlowSupported", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minWidth, settings, "uint32_t", "minWidth", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minHeight, settings, "uint32_t", "minHeight", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxWidth, settings, "uint32_t", "maxWidth", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxHeight, settings, "uint32_t", "maxHeight", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxNumRegionsOfInterest, settings, "uint32_t", "maxNumRegionsOfInterest", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkOpticalFlowImageFormatInfoNV(const VkOpticalFlowImageFormatInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkOpticalFlowUsageFlagsNV(object.usage, settings, "VkOpticalFlowUsageFlagsNV", "usage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkOpticalFlowImageFormatPropertiesNV(const VkOpticalFlowImageFormatPropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormat(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkOpticalFlowSessionCreateInfoNV(const VkOpticalFlowSessionCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.width, settings, "uint32_t", "width", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.height, settings, "uint32_t", "height", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormat(object.imageFormat, settings, "VkFormat", "imageFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormat(object.flowVectorFormat, settings, "VkFormat", "flowVectorFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormat(object.costFormat, settings, "VkFormat", "costFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkOpticalFlowGridSizeFlagsNV(object.outputGridSize, settings, "VkOpticalFlowGridSizeFlagsNV", "outputGridSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkOpticalFlowGridSizeFlagsNV(object.hintGridSize, settings, "VkOpticalFlowGridSizeFlagsNV", "hintGridSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkOpticalFlowPerformanceLevelNV(object.performanceLevel, settings, "VkOpticalFlowPerformanceLevelNV", "performanceLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkOpticalFlowSessionCreateFlagsNV(object.flags, settings, "VkOpticalFlowSessionCreateFlagsNV", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkOpticalFlowSessionCreatePrivateDataInfoNV(const VkOpticalFlowSessionCreatePrivateDataInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.id, settings, "uint32_t", "id", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.size, settings, "uint32_t", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pPrivateData, settings, "const void*", "pPrivateData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkOpticalFlowExecuteInfoNV(const VkOpticalFlowExecuteInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkOpticalFlowExecuteFlagsNV(object.flags, settings, "VkOpticalFlowExecuteFlagsNV", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.regionCount, settings, "uint32_t", "regionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pRegions, object.regionCount, settings, "const VkRect2D*", "pRegions", "const VkRect2D", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkRect2D); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceLegacyDitheringFeaturesEXT(const VkPhysicalDeviceLegacyDitheringFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.legacyDithering, settings, "VkBool32", "legacyDithering", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#if defined(VK_USE_PLATFORM_ANDROID_KHR) +template +void dump_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID(const VkPhysicalDeviceExternalFormatResolveFeaturesANDROID& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.externalFormatResolve, settings, "VkBool32", "externalFormatResolve", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID(const VkPhysicalDeviceExternalFormatResolvePropertiesANDROID& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.nullColorAttachmentWithExternalFormatResolve, settings, "VkBool32", "nullColorAttachmentWithExternalFormatResolve", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkChromaLocation(object.externalFormatResolveChromaOffsetX, settings, "VkChromaLocation", "externalFormatResolveChromaOffsetX", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkChromaLocation(object.externalFormatResolveChromaOffsetY, settings, "VkChromaLocation", "externalFormatResolveChromaOffsetY", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAndroidHardwareBufferFormatResolvePropertiesANDROID(const VkAndroidHardwareBufferFormatResolvePropertiesANDROID& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormat(object.colorAttachmentFormat, settings, "VkFormat", "colorAttachmentFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#endif // VK_USE_PLATFORM_ANDROID_KHR +template +void dump_VkPhysicalDeviceAntiLagFeaturesAMD(const VkPhysicalDeviceAntiLagFeaturesAMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.antiLag, settings, "VkBool32", "antiLag", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAntiLagPresentationInfoAMD(const VkAntiLagPresentationInfoAMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAntiLagStageAMD(object.stage, settings, "VkAntiLagStageAMD", "stage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.frameIndex, settings, "uint64_t", "frameIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAntiLagDataAMD(const VkAntiLagDataAMD& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAntiLagModeAMD(object.mode, settings, "VkAntiLagModeAMD", "mode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxFPS, settings, "uint32_t", "maxFPS", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pPresentationInfo, settings, "const VkAntiLagPresentationInfoAMD*", "pPresentationInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkAntiLagPresentationInfoAMD); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#if defined(VK_ENABLE_BETA_EXTENSIONS) +template +void dump_VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX(const VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.denseGeometryFormat, settings, "VkBool32", "denseGeometryFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX(const VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceOrHostAddressConstKHR(object.compressedData, settings, "VkDeviceOrHostAddressConstKHR", "compressedData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dataSize, settings, "VkDeviceSize", "dataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.numTriangles, settings, "uint32_t", "numTriangles", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.numVertices, settings, "uint32_t", "numVertices", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPrimitiveIndex, settings, "uint32_t", "maxPrimitiveIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxGeometryIndex, settings, "uint32_t", "maxGeometryIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkCompressedTriangleFormatAMDX(object.format, settings, "VkCompressedTriangleFormatAMDX", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#endif // VK_ENABLE_BETA_EXTENSIONS +template +void dump_VkPhysicalDeviceShaderObjectFeaturesEXT(const VkPhysicalDeviceShaderObjectFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderObject, settings, "VkBool32", "shaderObject", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderObjectPropertiesEXT(const VkPhysicalDeviceShaderObjectPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.shaderBinaryUUID, VK_UUID_SIZE, settings, "uint8_t[VK_UUID_SIZE]", "shaderBinaryUUID", "uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.shaderBinaryVersion, settings, "uint32_t", "shaderBinaryVersion", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkShaderCreateInfoEXT(const VkShaderCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkShaderCreateFlagsEXT(object.flags, settings, "VkShaderCreateFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkShaderStageFlagBits(object.stage, settings, "VkShaderStageFlagBits", "stage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkShaderStageFlags(object.nextStage, settings, "VkShaderStageFlags", "nextStage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkShaderCodeTypeEXT(object.codeType, settings, "VkShaderCodeTypeEXT", "codeType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.codeSize, settings, "size_t", "codeSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + + if (settings.showShader()) { + dump_spirv(object.pCode, object.codeSize, settings, "const void*", "pCode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + } else { + dump_special("SHADER DATA", settings, "const void*", "pCode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + } + dump_separate_members(settings); + dump_char(object.pName, settings, "const char*", "pName", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.setLayoutCount, settings, "uint32_t", "setLayoutCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pSetLayouts, object.setLayoutCount, settings, "const VkDescriptorSetLayout*", "pSetLayouts", "const VkDescriptorSetLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorSetLayout); + dump_separate_members(settings); + dump_type(object.pushConstantRangeCount, settings, "uint32_t", "pushConstantRangeCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pPushConstantRanges, object.pushConstantRangeCount, settings, "const VkPushConstantRange*", "pPushConstantRanges", "const VkPushConstantRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPushConstantRange); + dump_separate_members(settings); + dump_pointer(object.pSpecializationInfo, settings, "const VkSpecializationInfo*", "pSpecializationInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSpecializationInfo); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDepthClampRangeEXT(const VkDepthClampRangeEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.minDepthClamp, settings, "float", "minDepthClamp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDepthClamp, settings, "float", "maxDepthClamp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceTilePropertiesFeaturesQCOM(const VkPhysicalDeviceTilePropertiesFeaturesQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tileProperties, settings, "VkBool32", "tileProperties", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkTilePropertiesQCOM(const VkTilePropertiesQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent3D(object.tileSize, settings, "VkExtent3D", "tileSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.apronSize, settings, "VkExtent2D", "apronSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkOffset2D(object.origin, settings, "VkOffset2D", "origin", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceAmigoProfilingFeaturesSEC(const VkPhysicalDeviceAmigoProfilingFeaturesSEC& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.amigoProfiling, settings, "VkBool32", "amigoProfiling", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAmigoProfilingSubmitInfoSEC(const VkAmigoProfilingSubmitInfoSEC& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.firstDrawTimestamp, settings, "uint64_t", "firstDrawTimestamp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.swapBufferTimestamp, settings, "uint64_t", "swapBufferTimestamp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.multiviewPerViewViewports, settings, "VkBool32", "multiviewPerViewViewports", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkRayTracingInvocationReorderModeEXT(object.rayTracingInvocationReorderReorderingHint, settings, "VkRayTracingInvocationReorderModeEXT", "rayTracingInvocationReorderReorderingHint", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.rayTracingInvocationReorder, settings, "VkBool32", "rayTracingInvocationReorder", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceCooperativeVectorPropertiesNV(const VkPhysicalDeviceCooperativeVectorPropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkShaderStageFlags(object.cooperativeVectorSupportedStages, settings, "VkShaderStageFlags", "cooperativeVectorSupportedStages", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.cooperativeVectorTrainingFloat16Accumulation, settings, "VkBool32", "cooperativeVectorTrainingFloat16Accumulation", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.cooperativeVectorTrainingFloat32Accumulation, settings, "VkBool32", "cooperativeVectorTrainingFloat32Accumulation", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxCooperativeVectorComponents, settings, "uint32_t", "maxCooperativeVectorComponents", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceCooperativeVectorFeaturesNV(const VkPhysicalDeviceCooperativeVectorFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.cooperativeVector, settings, "VkBool32", "cooperativeVector", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.cooperativeVectorTraining, settings, "VkBool32", "cooperativeVectorTraining", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCooperativeVectorPropertiesNV(const VkCooperativeVectorPropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkComponentTypeKHR(object.inputType, settings, "VkComponentTypeKHR", "inputType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkComponentTypeKHR(object.inputInterpretation, settings, "VkComponentTypeKHR", "inputInterpretation", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkComponentTypeKHR(object.matrixInterpretation, settings, "VkComponentTypeKHR", "matrixInterpretation", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkComponentTypeKHR(object.biasInterpretation, settings, "VkComponentTypeKHR", "biasInterpretation", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkComponentTypeKHR(object.resultType, settings, "VkComponentTypeKHR", "resultType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.transpose, settings, "VkBool32", "transpose", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkConvertCooperativeVectorMatrixInfoNV(const VkConvertCooperativeVectorMatrixInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.srcSize, settings, "size_t", "srcSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceOrHostAddressConstKHR(object.srcData, settings, "VkDeviceOrHostAddressConstKHR", "srcData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pDstSize, settings, "size_t*", "pDstSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_VkDeviceOrHostAddressKHR(object.dstData, settings, "VkDeviceOrHostAddressKHR", "dstData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkComponentTypeKHR(object.srcComponentType, settings, "VkComponentTypeKHR", "srcComponentType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkComponentTypeKHR(object.dstComponentType, settings, "VkComponentTypeKHR", "dstComponentType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.numRows, settings, "uint32_t", "numRows", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.numColumns, settings, "uint32_t", "numColumns", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkCooperativeVectorMatrixLayoutNV(object.srcLayout, settings, "VkCooperativeVectorMatrixLayoutNV", "srcLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.srcStride, settings, "size_t", "srcStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkCooperativeVectorMatrixLayoutNV(object.dstLayout, settings, "VkCooperativeVectorMatrixLayoutNV", "dstLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dstStride, settings, "size_t", "dstStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV(const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.extendedSparseAddressSpace, settings, "VkBool32", "extendedSparseAddressSpace", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV(const VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.extendedSparseAddressSpaceSize, settings, "VkDeviceSize", "extendedSparseAddressSpaceSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkImageUsageFlags(object.extendedSparseImageUsageFlags, settings, "VkImageUsageFlags", "extendedSparseImageUsageFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBufferUsageFlags(object.extendedSparseBufferUsageFlags, settings, "VkBufferUsageFlags", "extendedSparseBufferUsageFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT(const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.legacyVertexAttributes, settings, "VkBool32", "legacyVertexAttributes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT(const VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.nativeUnalignedPerformance, settings, "VkBool32", "nativeUnalignedPerformance", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkLayerSettingEXT(const VkLayerSettingEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_char(object.pLayerName, settings, "const char*", "pLayerName", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_char(object.pSettingName, settings, "const char*", "pSettingName", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkLayerSettingTypeEXT(object.type, settings, "VkLayerSettingTypeEXT", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.valueCount, settings, "uint32_t", "valueCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pValues, settings, "const void*", "pValues", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkLayerSettingsCreateInfoEXT(const VkLayerSettingsCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.settingCount, settings, "uint32_t", "settingCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pSettings, object.settingCount, settings, "const VkLayerSettingEXT*", "pSettings", "const VkLayerSettingEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkLayerSettingEXT); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderCoreBuiltins, settings, "VkBool32", "shaderCoreBuiltins", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderCoreMask, settings, "uint64_t", "shaderCoreMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderCoreCount, settings, "uint32_t", "shaderCoreCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderWarpsPerCore, settings, "uint32_t", "shaderWarpsPerCore", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pipelineLibraryGroupHandles, settings, "VkBool32", "pipelineLibraryGroupHandles", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT(const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dynamicRenderingUnusedAttachments, settings, "VkBool32", "dynamicRenderingUnusedAttachments", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkLatencySleepModeInfoNV(const VkLatencySleepModeInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.lowLatencyMode, settings, "VkBool32", "lowLatencyMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.lowLatencyBoost, settings, "VkBool32", "lowLatencyBoost", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minimumIntervalUs, settings, "uint32_t", "minimumIntervalUs", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkLatencySleepInfoNV(const VkLatencySleepInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSemaphore(object.signalSemaphore, settings, "VkSemaphore", "signalSemaphore", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.value, settings, "uint64_t", "value", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSetLatencyMarkerInfoNV(const VkSetLatencyMarkerInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.presentID, settings, "uint64_t", "presentID", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkLatencyMarkerNV(object.marker, settings, "VkLatencyMarkerNV", "marker", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkLatencyTimingsFrameReportNV(const VkLatencyTimingsFrameReportNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.presentID, settings, "uint64_t", "presentID", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.inputSampleTimeUs, settings, "uint64_t", "inputSampleTimeUs", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.simStartTimeUs, settings, "uint64_t", "simStartTimeUs", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.simEndTimeUs, settings, "uint64_t", "simEndTimeUs", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.renderSubmitStartTimeUs, settings, "uint64_t", "renderSubmitStartTimeUs", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.renderSubmitEndTimeUs, settings, "uint64_t", "renderSubmitEndTimeUs", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.presentStartTimeUs, settings, "uint64_t", "presentStartTimeUs", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.presentEndTimeUs, settings, "uint64_t", "presentEndTimeUs", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.driverStartTimeUs, settings, "uint64_t", "driverStartTimeUs", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.driverEndTimeUs, settings, "uint64_t", "driverEndTimeUs", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.osRenderQueueStartTimeUs, settings, "uint64_t", "osRenderQueueStartTimeUs", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.osRenderQueueEndTimeUs, settings, "uint64_t", "osRenderQueueEndTimeUs", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.gpuRenderStartTimeUs, settings, "uint64_t", "gpuRenderStartTimeUs", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.gpuRenderEndTimeUs, settings, "uint64_t", "gpuRenderEndTimeUs", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkGetLatencyMarkerInfoNV(const VkGetLatencyMarkerInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.timingCount, settings, "uint32_t", "timingCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pTimings, object.timingCount, settings, "VkLatencyTimingsFrameReportNV*", "pTimings", "VkLatencyTimingsFrameReportNV", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkLatencyTimingsFrameReportNV); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkLatencySubmissionPresentIdNV(const VkLatencySubmissionPresentIdNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.presentID, settings, "uint64_t", "presentID", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSwapchainLatencyCreateInfoNV(const VkSwapchainLatencyCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.latencyModeEnable, settings, "VkBool32", "latencyModeEnable", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkOutOfBandQueueTypeInfoNV(const VkOutOfBandQueueTypeInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkOutOfBandQueueTypeNV(object.queueType, settings, "VkOutOfBandQueueTypeNV", "queueType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkLatencySurfaceCapabilitiesNV(const VkLatencySurfaceCapabilitiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.presentModeCount, settings, "uint32_t", "presentModeCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pPresentModes, object.presentModeCount, settings, "VkPresentModeKHR*", "pPresentModes", "VkPresentModeKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPresentModeKHR); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceDataGraphFeaturesARM(const VkPhysicalDeviceDataGraphFeaturesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dataGraph, settings, "VkBool32", "dataGraph", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dataGraphUpdateAfterBind, settings, "VkBool32", "dataGraphUpdateAfterBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dataGraphSpecializationConstants, settings, "VkBool32", "dataGraphSpecializationConstants", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dataGraphDescriptorBuffer, settings, "VkBool32", "dataGraphDescriptorBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dataGraphShaderModule, settings, "VkBool32", "dataGraphShaderModule", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDataGraphPipelineConstantARM(const VkDataGraphPipelineConstantARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.id, settings, "uint32_t", "id", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pConstantData, settings, "const void*", "pConstantData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDataGraphPipelineResourceInfoARM(const VkDataGraphPipelineResourceInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorSet, settings, "uint32_t", "descriptorSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.binding, settings, "uint32_t", "binding", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.arrayElement, settings, "uint32_t", "arrayElement", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDataGraphPipelineCompilerControlCreateInfoARM(const VkDataGraphPipelineCompilerControlCreateInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_char(object.pVendorOptions, settings, "const char*", "pVendorOptions", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDataGraphPipelineCreateInfoARM(const VkDataGraphPipelineCreateInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineCreateFlags2(object.flags, settings, "VkPipelineCreateFlags2KHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineLayout(object.layout, settings, "VkPipelineLayout", "layout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.resourceInfoCount, settings, "uint32_t", "resourceInfoCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pResourceInfos, object.resourceInfoCount, settings, "const VkDataGraphPipelineResourceInfoARM*", "pResourceInfos", "const VkDataGraphPipelineResourceInfoARM", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDataGraphPipelineResourceInfoARM); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDataGraphPipelineShaderModuleCreateInfoARM(const VkDataGraphPipelineShaderModuleCreateInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkShaderModule(object.module, settings, "VkShaderModule", "module", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_char(object.pName, settings, "const char*", "pName", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pSpecializationInfo, settings, "const VkSpecializationInfo*", "pSpecializationInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkSpecializationInfo); + dump_separate_members(settings); + dump_type(object.constantCount, settings, "uint32_t", "constantCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pConstants, object.constantCount, settings, "const VkDataGraphPipelineConstantARM*", "pConstants", "const VkDataGraphPipelineConstantARM", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDataGraphPipelineConstantARM); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDataGraphPipelineSessionCreateInfoARM(const VkDataGraphPipelineSessionCreateInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDataGraphPipelineSessionCreateFlagsARM(object.flags, settings, "VkDataGraphPipelineSessionCreateFlagsARM", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipeline(object.dataGraphPipeline, settings, "VkPipeline", "dataGraphPipeline", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDataGraphPipelineSessionBindPointRequirementsInfoARM(const VkDataGraphPipelineSessionBindPointRequirementsInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDataGraphPipelineSessionARM(object.session, settings, "VkDataGraphPipelineSessionARM", "session", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDataGraphPipelineSessionBindPointRequirementARM(const VkDataGraphPipelineSessionBindPointRequirementARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDataGraphPipelineSessionBindPointARM(object.bindPoint, settings, "VkDataGraphPipelineSessionBindPointARM", "bindPoint", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDataGraphPipelineSessionBindPointTypeARM(object.bindPointType, settings, "VkDataGraphPipelineSessionBindPointTypeARM", "bindPointType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.numObjects, settings, "uint32_t", "numObjects", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDataGraphPipelineSessionMemoryRequirementsInfoARM(const VkDataGraphPipelineSessionMemoryRequirementsInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDataGraphPipelineSessionARM(object.session, settings, "VkDataGraphPipelineSessionARM", "session", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDataGraphPipelineSessionBindPointARM(object.bindPoint, settings, "VkDataGraphPipelineSessionBindPointARM", "bindPoint", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.objectIndex, settings, "uint32_t", "objectIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBindDataGraphPipelineSessionMemoryInfoARM(const VkBindDataGraphPipelineSessionMemoryInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDataGraphPipelineSessionARM(object.session, settings, "VkDataGraphPipelineSessionARM", "session", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDataGraphPipelineSessionBindPointARM(object.bindPoint, settings, "VkDataGraphPipelineSessionBindPointARM", "bindPoint", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.objectIndex, settings, "uint32_t", "objectIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceMemory(object.memory, settings, "VkDeviceMemory", "memory", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.memoryOffset, settings, "VkDeviceSize", "memoryOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDataGraphPipelineInfoARM(const VkDataGraphPipelineInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipeline(object.dataGraphPipeline, settings, "VkPipeline", "dataGraphPipeline", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDataGraphPipelinePropertyQueryResultARM(const VkDataGraphPipelinePropertyQueryResultARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDataGraphPipelinePropertyARM(object.property, settings, "VkDataGraphPipelinePropertyARM", "property", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.isText, settings, "VkBool32", "isText", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dataSize, settings, "size_t", "dataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pData, settings, "void*", "pData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDataGraphPipelineIdentifierCreateInfoARM(const VkDataGraphPipelineIdentifierCreateInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.identifierSize, settings, "uint32_t", "identifierSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pIdentifier, object.identifierSize, settings, "const uint8_t*", "pIdentifier", "const uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDataGraphPipelineDispatchInfoARM(const VkDataGraphPipelineDispatchInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDataGraphPipelineDispatchFlagsARM(object.flags, settings, "VkDataGraphPipelineDispatchFlagsARM", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceDataGraphProcessingEngineARM(const VkPhysicalDeviceDataGraphProcessingEngineARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkPhysicalDeviceDataGraphProcessingEngineTypeARM(object.type, settings, "VkPhysicalDeviceDataGraphProcessingEngineTypeARM", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.isForeign, settings, "VkBool32", "isForeign", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceDataGraphOperationSupportARM(const VkPhysicalDeviceDataGraphOperationSupportARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkPhysicalDeviceDataGraphOperationTypeARM(object.operationType, settings, "VkPhysicalDeviceDataGraphOperationTypeARM", "operationType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_char(object.name, settings, "char[VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM]", "name", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.version, settings, "uint32_t", "version", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkQueueFamilyDataGraphPropertiesARM(const VkQueueFamilyDataGraphPropertiesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPhysicalDeviceDataGraphProcessingEngineARM(object.engine, settings, "VkPhysicalDeviceDataGraphProcessingEngineARM", "engine", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPhysicalDeviceDataGraphOperationSupportARM(object.operation, settings, "VkPhysicalDeviceDataGraphOperationSupportARM", "operation", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDataGraphProcessingEngineCreateInfoARM(const VkDataGraphProcessingEngineCreateInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.processingEngineCount, settings, "uint32_t", "processingEngineCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pProcessingEngines, object.processingEngineCount, settings, "VkPhysicalDeviceDataGraphProcessingEngineARM*", "pProcessingEngines", "VkPhysicalDeviceDataGraphProcessingEngineARM", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPhysicalDeviceDataGraphProcessingEngineARM); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM(const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPhysicalDeviceDataGraphProcessingEngineTypeARM(object.engineType, settings, "VkPhysicalDeviceDataGraphProcessingEngineTypeARM", "engineType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkQueueFamilyDataGraphProcessingEnginePropertiesARM(const VkQueueFamilyDataGraphProcessingEnginePropertiesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalSemaphoreHandleTypeFlags(object.foreignSemaphoreHandleTypes, settings, "VkExternalSemaphoreHandleTypeFlags", "foreignSemaphoreHandleTypes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalMemoryHandleTypeFlags(object.foreignMemoryHandleTypes, settings, "VkExternalMemoryHandleTypeFlags", "foreignMemoryHandleTypes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM(const VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dimension, settings, "uint32_t", "dimension", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.zeroCount, settings, "uint32_t", "zeroCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.groupSize, settings, "uint32_t", "groupSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.multiviewPerViewRenderAreas, settings, "VkBool32", "multiviewPerViewRenderAreas", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.perViewRenderAreaCount, settings, "uint32_t", "perViewRenderAreaCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pPerViewRenderAreas, object.perViewRenderAreaCount, settings, "const VkRect2D*", "pPerViewRenderAreas", "const VkRect2D", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkRect2D); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDevicePerStageDescriptorSetFeaturesNV(const VkPhysicalDevicePerStageDescriptorSetFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.perStageDescriptorSet, settings, "VkBool32", "perStageDescriptorSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dynamicPipelineLayout, settings, "VkBool32", "dynamicPipelineLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceImageProcessing2FeaturesQCOM(const VkPhysicalDeviceImageProcessing2FeaturesQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.textureBlockMatch2, settings, "VkBool32", "textureBlockMatch2", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceImageProcessing2PropertiesQCOM(const VkPhysicalDeviceImageProcessing2PropertiesQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.maxBlockMatchWindow, settings, "VkExtent2D", "maxBlockMatchWindow", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSamplerBlockMatchWindowCreateInfoQCOM(const VkSamplerBlockMatchWindowCreateInfoQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.windowExtent, settings, "VkExtent2D", "windowExtent", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBlockMatchWindowCompareModeQCOM(object.windowCompareMode, settings, "VkBlockMatchWindowCompareModeQCOM", "windowCompareMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceCubicWeightsFeaturesQCOM(const VkPhysicalDeviceCubicWeightsFeaturesQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.selectableCubicWeights, settings, "VkBool32", "selectableCubicWeights", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSamplerCubicWeightsCreateInfoQCOM(const VkSamplerCubicWeightsCreateInfoQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkCubicFilterWeightsQCOM(object.cubicWeights, settings, "VkCubicFilterWeightsQCOM", "cubicWeights", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBlitImageCubicWeightsInfoQCOM(const VkBlitImageCubicWeightsInfoQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkCubicFilterWeightsQCOM(object.cubicWeights, settings, "VkCubicFilterWeightsQCOM", "cubicWeights", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM(const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.ycbcrDegamma, settings, "VkBool32", "ycbcrDegamma", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM(const VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.enableYDegamma, settings, "VkBool32", "enableYDegamma", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.enableCbCrDegamma, settings, "VkBool32", "enableCbCrDegamma", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceCubicClampFeaturesQCOM(const VkPhysicalDeviceCubicClampFeaturesQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.cubicRangeClamp, settings, "VkBool32", "cubicRangeClamp", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.attachmentFeedbackLoopDynamicState, settings, "VkBool32", "attachmentFeedbackLoopDynamicState", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#if defined(VK_USE_PLATFORM_SCREEN_QNX) +template +void dump_VkScreenBufferPropertiesQNX(const VkScreenBufferPropertiesQNX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.allocationSize, settings, "VkDeviceSize", "allocationSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.memoryTypeBits, settings, "uint32_t", "memoryTypeBits", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkScreenBufferFormatPropertiesQNX(const VkScreenBufferFormatPropertiesQNX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormat(object.format, settings, "VkFormat", "format", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.externalFormat, settings, "uint64_t", "externalFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.screenUsage, settings, "uint64_t", "screenUsage", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormatFeatureFlags(object.formatFeatures, settings, "VkFormatFeatureFlags", "formatFeatures", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkComponentMapping(object.samplerYcbcrConversionComponents, settings, "VkComponentMapping", "samplerYcbcrConversionComponents", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSamplerYcbcrModelConversion(object.suggestedYcbcrModel, settings, "VkSamplerYcbcrModelConversion", "suggestedYcbcrModel", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSamplerYcbcrRange(object.suggestedYcbcrRange, settings, "VkSamplerYcbcrRange", "suggestedYcbcrRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkChromaLocation(object.suggestedXChromaOffset, settings, "VkChromaLocation", "suggestedXChromaOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkChromaLocation(object.suggestedYChromaOffset, settings, "VkChromaLocation", "suggestedYChromaOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImportScreenBufferInfoQNX(const VkImportScreenBufferInfoQNX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.buffer, settings, "struct _screen_buffer*", "buffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkExternalFormatQNX(const VkExternalFormatQNX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.externalFormat, settings, "uint64_t", "externalFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX(const VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.screenBufferImport, settings, "VkBool32", "screenBufferImport", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#endif // VK_USE_PLATFORM_SCREEN_QNX +template +void dump_VkPhysicalDeviceLayeredDriverPropertiesMSFT(const VkPhysicalDeviceLayeredDriverPropertiesMSFT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkLayeredDriverUnderlyingApiMSFT(object.underlyingAPI, settings, "VkLayeredDriverUnderlyingApiMSFT", "underlyingAPI", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV(const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorPoolOverallocation, settings, "VkBool32", "descriptorPoolOverallocation", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM(const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tileMemoryHeap, settings, "VkBool32", "tileMemoryHeap", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM(const VkPhysicalDeviceTileMemoryHeapPropertiesQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.queueSubmitBoundary, settings, "VkBool32", "queueSubmitBoundary", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tileBufferTransfers, settings, "VkBool32", "tileBufferTransfers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkTileMemoryRequirementsQCOM(const VkTileMemoryRequirementsQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.alignment, settings, "VkDeviceSize", "alignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkTileMemoryBindInfoQCOM(const VkTileMemoryBindInfoQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceMemory(object.memory, settings, "VkDeviceMemory", "memory", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkTileMemorySizeInfoQCOM(const VkTileMemorySizeInfoQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDecompressMemoryRegionEXT(const VkDecompressMemoryRegionEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type_hex(object.srcAddress, settings, "VkDeviceAddress", "srcAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type_hex(object.dstAddress, settings, "VkDeviceAddress", "dstAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.compressedSize, settings, "VkDeviceSize", "compressedSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.decompressedSize, settings, "VkDeviceSize", "decompressedSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDecompressMemoryInfoEXT(const VkDecompressMemoryInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkMemoryDecompressionMethodFlagsEXT(object.decompressionMethod, settings, "VkMemoryDecompressionMethodFlagsEXT", "decompressionMethod", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.regionCount, settings, "uint32_t", "regionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pRegions, object.regionCount, settings, "const VkDecompressMemoryRegionEXT*", "pRegions", "const VkDecompressMemoryRegionEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDecompressMemoryRegionEXT); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDisplaySurfaceStereoCreateInfoNV(const VkDisplaySurfaceStereoCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDisplaySurfaceStereoTypeNV(object.stereoType, settings, "VkDisplaySurfaceStereoTypeNV", "stereoType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDisplayModeStereoPropertiesNV(const VkDisplayModeStereoPropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.hdmi3DSupported, settings, "VkBool32", "hdmi3DSupported", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceRawAccessChainsFeaturesNV(const VkPhysicalDeviceRawAccessChainsFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderRawAccessChains, settings, "VkBool32", "shaderRawAccessChains", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkExternalComputeQueueDeviceCreateInfoNV(const VkExternalComputeQueueDeviceCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reservedExternalQueues, settings, "uint32_t", "reservedExternalQueues", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkExternalComputeQueueCreateInfoNV(const VkExternalComputeQueueCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkQueue(object.preferredQueue, settings, "VkQueue", "preferredQueue", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkExternalComputeQueueDataParamsNV(const VkExternalComputeQueueDataParamsNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.deviceIndex, settings, "uint32_t", "deviceIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceExternalComputeQueuePropertiesNV(const VkPhysicalDeviceExternalComputeQueuePropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.externalDataSize, settings, "uint32_t", "externalDataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxExternalQueues, settings, "uint32_t", "maxExternalQueues", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV(const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.commandBufferInheritance, settings, "VkBool32", "commandBufferInheritance", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV(const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderFloat16VectorAtomics, settings, "VkBool32", "shaderFloat16VectorAtomics", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT(const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderReplicatedComposites, settings, "VkBool32", "shaderReplicatedComposites", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderFloat8FeaturesEXT(const VkPhysicalDeviceShaderFloat8FeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderFloat8, settings, "VkBool32", "shaderFloat8", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderFloat8CooperativeMatrix, settings, "VkBool32", "shaderFloat8CooperativeMatrix", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceRayTracingValidationFeaturesNV(const VkPhysicalDeviceRayTracingValidationFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.rayTracingValidation, settings, "VkBool32", "rayTracingValidation", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV(const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.clusterAccelerationStructure, settings, "VkBool32", "clusterAccelerationStructure", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV(const VkPhysicalDeviceClusterAccelerationStructurePropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxVerticesPerCluster, settings, "uint32_t", "maxVerticesPerCluster", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxTrianglesPerCluster, settings, "uint32_t", "maxTrianglesPerCluster", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.clusterScratchByteAlignment, settings, "uint32_t", "clusterScratchByteAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.clusterByteAlignment, settings, "uint32_t", "clusterByteAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.clusterTemplateByteAlignment, settings, "uint32_t", "clusterTemplateByteAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.clusterBottomLevelByteAlignment, settings, "uint32_t", "clusterBottomLevelByteAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.clusterTemplateBoundsByteAlignment, settings, "uint32_t", "clusterTemplateBoundsByteAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxClusterGeometryIndex, settings, "uint32_t", "maxClusterGeometryIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkClusterAccelerationStructureClustersBottomLevelInputNV(const VkClusterAccelerationStructureClustersBottomLevelInputNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxTotalClusterCount, settings, "uint32_t", "maxTotalClusterCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxClusterCountPerAccelerationStructure, settings, "uint32_t", "maxClusterCountPerAccelerationStructure", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkClusterAccelerationStructureTriangleClusterInputNV(const VkClusterAccelerationStructureTriangleClusterInputNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormat(object.vertexFormat, settings, "VkFormat", "vertexFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxGeometryIndexValue, settings, "uint32_t", "maxGeometryIndexValue", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxClusterUniqueGeometryCount, settings, "uint32_t", "maxClusterUniqueGeometryCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxClusterTriangleCount, settings, "uint32_t", "maxClusterTriangleCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxClusterVertexCount, settings, "uint32_t", "maxClusterVertexCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxTotalTriangleCount, settings, "uint32_t", "maxTotalTriangleCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxTotalVertexCount, settings, "uint32_t", "maxTotalVertexCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minPositionTruncateBitCount, settings, "uint32_t", "minPositionTruncateBitCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkClusterAccelerationStructureMoveObjectsInputNV(const VkClusterAccelerationStructureMoveObjectsInputNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkClusterAccelerationStructureTypeNV(object.type, settings, "VkClusterAccelerationStructureTypeNV", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.noMoveOverlap, settings, "VkBool32", "noMoveOverlap", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxMovedBytes, settings, "VkDeviceSize", "maxMovedBytes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkClusterAccelerationStructureOpInputNV(const VkClusterAccelerationStructureOpInputNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_union, type_name, var_name, indents, address); + dump_pointer(object.pClustersBottomLevel, settings, "VkClusterAccelerationStructureClustersBottomLevelInputNV*", "pClustersBottomLevel", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkClusterAccelerationStructureClustersBottomLevelInputNV); + dump_separate_members(settings); + dump_pointer(object.pTriangleClusters, settings, "VkClusterAccelerationStructureTriangleClusterInputNV*", "pTriangleClusters", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkClusterAccelerationStructureTriangleClusterInputNV); + dump_separate_members(settings); + dump_pointer(object.pMoveObjects, settings, "VkClusterAccelerationStructureMoveObjectsInputNV*", "pMoveObjects", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkClusterAccelerationStructureMoveObjectsInputNV); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkClusterAccelerationStructureInputInfoNV(const VkClusterAccelerationStructureInputInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxAccelerationStructureCount, settings, "uint32_t", "maxAccelerationStructureCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBuildAccelerationStructureFlagsKHR(object.flags, settings, "VkBuildAccelerationStructureFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkClusterAccelerationStructureOpTypeNV(object.opType, settings, "VkClusterAccelerationStructureOpTypeNV", "opType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkClusterAccelerationStructureOpModeNV(object.opMode, settings, "VkClusterAccelerationStructureOpModeNV", "opMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkClusterAccelerationStructureOpInputNV(object.opInput, settings, "VkClusterAccelerationStructureOpInputNV", "opInput", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkStridedDeviceAddressRegionKHR(const VkStridedDeviceAddressRegionKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type_hex(object.deviceAddress, settings, "VkDeviceAddress", "deviceAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.stride, settings, "VkDeviceSize", "stride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkClusterAccelerationStructureCommandsInfoNV(const VkClusterAccelerationStructureCommandsInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkClusterAccelerationStructureInputInfoNV(object.input, settings, "VkClusterAccelerationStructureInputInfoNV", "input", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type_hex(object.dstImplicitData, settings, "VkDeviceAddress", "dstImplicitData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type_hex(object.scratchData, settings, "VkDeviceAddress", "scratchData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkStridedDeviceAddressRegionKHR(object.dstAddressesArray, settings, "VkStridedDeviceAddressRegionKHR", "dstAddressesArray", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkStridedDeviceAddressRegionKHR(object.dstSizesArray, settings, "VkStridedDeviceAddressRegionKHR", "dstSizesArray", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkStridedDeviceAddressRegionKHR(object.srcInfosArray, settings, "VkStridedDeviceAddressRegionKHR", "srcInfosArray", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type_hex(object.srcInfosCount, settings, "VkDeviceAddress", "srcInfosCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkClusterAccelerationStructureAddressResolutionFlagsNV(object.addressResolutionFlags, settings, "VkClusterAccelerationStructureAddressResolutionFlagsNV", "addressResolutionFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkStridedDeviceAddressNV(const VkStridedDeviceAddressNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type_hex(object.startAddress, settings, "VkDeviceAddress", "startAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.strideInBytes, settings, "VkDeviceSize", "strideInBytes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV(const VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.geometryIndex, settings, "uint32_t:24", "geometryIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved, settings, "uint32_t:5", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.geometryFlags, settings, "uint32_t:3", "geometryFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkClusterAccelerationStructureMoveObjectsInfoNV(const VkClusterAccelerationStructureMoveObjectsInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type_hex(object.srcAccelerationStructure, settings, "VkDeviceAddress", "srcAccelerationStructure", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV(const VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.clusterReferencesCount, settings, "uint32_t", "clusterReferencesCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.clusterReferencesStride, settings, "uint32_t", "clusterReferencesStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type_hex(object.clusterReferences, settings, "VkDeviceAddress", "clusterReferences", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkClusterAccelerationStructureBuildTriangleClusterInfoNV(const VkClusterAccelerationStructureBuildTriangleClusterInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.clusterID, settings, "uint32_t", "clusterID", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkClusterAccelerationStructureClusterFlagsNV(object.clusterFlags, settings, "VkClusterAccelerationStructureClusterFlagsNV", "clusterFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.triangleCount, settings, "uint32_t:9", "triangleCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vertexCount, settings, "uint32_t:9", "vertexCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.positionTruncateBitCount, settings, "uint32_t:6", "positionTruncateBitCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.indexType, settings, "uint32_t:4", "indexType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.opacityMicromapIndexType, settings, "uint32_t:4", "opacityMicromapIndexType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV(object.baseGeometryIndexAndGeometryFlags, settings, "VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV", "baseGeometryIndexAndGeometryFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.indexBufferStride, settings, "uint16_t", "indexBufferStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vertexBufferStride, settings, "uint16_t", "vertexBufferStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.geometryIndexAndFlagsBufferStride, settings, "uint16_t", "geometryIndexAndFlagsBufferStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.opacityMicromapIndexBufferStride, settings, "uint16_t", "opacityMicromapIndexBufferStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type_hex(object.indexBuffer, settings, "VkDeviceAddress", "indexBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type_hex(object.vertexBuffer, settings, "VkDeviceAddress", "vertexBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type_hex(object.geometryIndexAndFlagsBuffer, settings, "VkDeviceAddress", "geometryIndexAndFlagsBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type_hex(object.opacityMicromapArray, settings, "VkDeviceAddress", "opacityMicromapArray", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type_hex(object.opacityMicromapIndexBuffer, settings, "VkDeviceAddress", "opacityMicromapIndexBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV(const VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.clusterID, settings, "uint32_t", "clusterID", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkClusterAccelerationStructureClusterFlagsNV(object.clusterFlags, settings, "VkClusterAccelerationStructureClusterFlagsNV", "clusterFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.triangleCount, settings, "uint32_t:9", "triangleCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vertexCount, settings, "uint32_t:9", "vertexCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.positionTruncateBitCount, settings, "uint32_t:6", "positionTruncateBitCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.indexType, settings, "uint32_t:4", "indexType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.opacityMicromapIndexType, settings, "uint32_t:4", "opacityMicromapIndexType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV(object.baseGeometryIndexAndGeometryFlags, settings, "VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV", "baseGeometryIndexAndGeometryFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.indexBufferStride, settings, "uint16_t", "indexBufferStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vertexBufferStride, settings, "uint16_t", "vertexBufferStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.geometryIndexAndFlagsBufferStride, settings, "uint16_t", "geometryIndexAndFlagsBufferStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.opacityMicromapIndexBufferStride, settings, "uint16_t", "opacityMicromapIndexBufferStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type_hex(object.indexBuffer, settings, "VkDeviceAddress", "indexBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type_hex(object.vertexBuffer, settings, "VkDeviceAddress", "vertexBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type_hex(object.geometryIndexAndFlagsBuffer, settings, "VkDeviceAddress", "geometryIndexAndFlagsBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type_hex(object.opacityMicromapArray, settings, "VkDeviceAddress", "opacityMicromapArray", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type_hex(object.opacityMicromapIndexBuffer, settings, "VkDeviceAddress", "opacityMicromapIndexBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type_hex(object.instantiationBoundingBoxLimit, settings, "VkDeviceAddress", "instantiationBoundingBoxLimit", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkClusterAccelerationStructureInstantiateClusterInfoNV(const VkClusterAccelerationStructureInstantiateClusterInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.clusterIdOffset, settings, "uint32_t", "clusterIdOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.geometryIndexOffset, settings, "uint32_t:24", "geometryIndexOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.reserved, settings, "uint32_t:8", "reserved", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type_hex(object.clusterTemplateAddress, settings, "VkDeviceAddress", "clusterTemplateAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkStridedDeviceAddressNV(object.vertexBuffer, settings, "VkStridedDeviceAddressNV", "vertexBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkClusterAccelerationStructureGetTemplateIndicesInfoNV(const VkClusterAccelerationStructureGetTemplateIndicesInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type_hex(object.clusterTemplateAddress, settings, "VkDeviceAddress", "clusterTemplateAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAccelerationStructureBuildSizesInfoKHR(const VkAccelerationStructureBuildSizesInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.accelerationStructureSize, settings, "VkDeviceSize", "accelerationStructureSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.updateScratchSize, settings, "VkDeviceSize", "updateScratchSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.buildScratchSize, settings, "VkDeviceSize", "buildScratchSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV(const VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.allowClusterAccelerationStructure, settings, "VkBool32", "allowClusterAccelerationStructure", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV(const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.partitionedAccelerationStructure, settings, "VkBool32", "partitionedAccelerationStructure", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV(const VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPartitionCount, settings, "uint32_t", "maxPartitionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPartitionedAccelerationStructureFlagsNV(const VkPartitionedAccelerationStructureFlagsNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.enablePartitionTranslation, settings, "VkBool32", "enablePartitionTranslation", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBuildPartitionedAccelerationStructureIndirectCommandNV(const VkBuildPartitionedAccelerationStructureIndirectCommandNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkPartitionedAccelerationStructureOpTypeNV(object.opType, settings, "VkPartitionedAccelerationStructureOpTypeNV", "opType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.argCount, settings, "uint32_t", "argCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkStridedDeviceAddressNV(object.argData, settings, "VkStridedDeviceAddressNV", "argData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPartitionedAccelerationStructureWriteInstanceDataNV(const VkPartitionedAccelerationStructureWriteInstanceDataNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkTransformMatrixKHR(object.transform, settings, "VkTransformMatrixKHR", "transform", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.explicitAABB, 6, settings, "float[6]", "explicitAABB", "float", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.instanceID, settings, "uint32_t", "instanceID", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.instanceMask, settings, "uint32_t", "instanceMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.instanceContributionToHitGroupIndex, settings, "uint32_t", "instanceContributionToHitGroupIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPartitionedAccelerationStructureInstanceFlagsNV(object.instanceFlags, settings, "VkPartitionedAccelerationStructureInstanceFlagsNV", "instanceFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.instanceIndex, settings, "uint32_t", "instanceIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.partitionIndex, settings, "uint32_t", "partitionIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type_hex(object.accelerationStructure, settings, "VkDeviceAddress", "accelerationStructure", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPartitionedAccelerationStructureUpdateInstanceDataNV(const VkPartitionedAccelerationStructureUpdateInstanceDataNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.instanceIndex, settings, "uint32_t", "instanceIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.instanceContributionToHitGroupIndex, settings, "uint32_t", "instanceContributionToHitGroupIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type_hex(object.accelerationStructure, settings, "VkDeviceAddress", "accelerationStructure", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPartitionedAccelerationStructureWritePartitionTranslationDataNV(const VkPartitionedAccelerationStructureWritePartitionTranslationDataNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.partitionIndex, settings, "uint32_t", "partitionIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.partitionTranslation, 3, settings, "float[3]", "partitionTranslation", "float", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkWriteDescriptorSetPartitionedAccelerationStructureNV(const VkWriteDescriptorSetPartitionedAccelerationStructureNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.accelerationStructureCount, settings, "uint32_t", "accelerationStructureCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pAccelerationStructures, object.accelerationStructureCount, settings, "const VkDeviceAddress*", "pAccelerationStructures", "const VkDeviceAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPartitionedAccelerationStructureInstancesInputNV(const VkPartitionedAccelerationStructureInstancesInputNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBuildAccelerationStructureFlagsKHR(object.flags, settings, "VkBuildAccelerationStructureFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.instanceCount, settings, "uint32_t", "instanceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxInstancePerPartitionCount, settings, "uint32_t", "maxInstancePerPartitionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.partitionCount, settings, "uint32_t", "partitionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxInstanceInGlobalPartitionCount, settings, "uint32_t", "maxInstanceInGlobalPartitionCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBuildPartitionedAccelerationStructureInfoNV(const VkBuildPartitionedAccelerationStructureInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPartitionedAccelerationStructureInstancesInputNV(object.input, settings, "VkPartitionedAccelerationStructureInstancesInputNV", "input", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type_hex(object.srcAccelerationStructureData, settings, "VkDeviceAddress", "srcAccelerationStructureData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type_hex(object.dstAccelerationStructureData, settings, "VkDeviceAddress", "dstAccelerationStructureData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type_hex(object.scratchData, settings, "VkDeviceAddress", "scratchData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type_hex(object.srcInfos, settings, "VkDeviceAddress", "srcInfos", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type_hex(object.srcInfosCount, settings, "VkDeviceAddress", "srcInfosCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT(const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.deviceGeneratedCommands, settings, "VkBool32", "deviceGeneratedCommands", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dynamicGeneratedPipelineLayout, settings, "VkBool32", "dynamicGeneratedPipelineLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT(const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxIndirectPipelineCount, settings, "uint32_t", "maxIndirectPipelineCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxIndirectShaderObjectCount, settings, "uint32_t", "maxIndirectShaderObjectCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxIndirectSequenceCount, settings, "uint32_t", "maxIndirectSequenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxIndirectCommandsTokenCount, settings, "uint32_t", "maxIndirectCommandsTokenCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxIndirectCommandsTokenOffset, settings, "uint32_t", "maxIndirectCommandsTokenOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxIndirectCommandsIndirectStride, settings, "uint32_t", "maxIndirectCommandsIndirectStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkIndirectCommandsInputModeFlagsEXT(object.supportedIndirectCommandsInputModes, settings, "VkIndirectCommandsInputModeFlagsEXT", "supportedIndirectCommandsInputModes", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkShaderStageFlags(object.supportedIndirectCommandsShaderStages, settings, "VkShaderStageFlags", "supportedIndirectCommandsShaderStages", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkShaderStageFlags(object.supportedIndirectCommandsShaderStagesPipelineBinding, settings, "VkShaderStageFlags", "supportedIndirectCommandsShaderStagesPipelineBinding", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkShaderStageFlags(object.supportedIndirectCommandsShaderStagesShaderBinding, settings, "VkShaderStageFlags", "supportedIndirectCommandsShaderStagesShaderBinding", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.deviceGeneratedCommandsTransformFeedback, settings, "VkBool32", "deviceGeneratedCommandsTransformFeedback", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.deviceGeneratedCommandsMultiDrawIndirectCount, settings, "VkBool32", "deviceGeneratedCommandsMultiDrawIndirectCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkGeneratedCommandsMemoryRequirementsInfoEXT(const VkGeneratedCommandsMemoryRequirementsInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkIndirectExecutionSetEXT(object.indirectExecutionSet, settings, "VkIndirectExecutionSetEXT", "indirectExecutionSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkIndirectCommandsLayoutEXT(object.indirectCommandsLayout, settings, "VkIndirectCommandsLayoutEXT", "indirectCommandsLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxSequenceCount, settings, "uint32_t", "maxSequenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDrawCount, settings, "uint32_t", "maxDrawCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkIndirectExecutionSetPipelineInfoEXT(const VkIndirectExecutionSetPipelineInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipeline(object.initialPipeline, settings, "VkPipeline", "initialPipeline", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPipelineCount, settings, "uint32_t", "maxPipelineCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkIndirectExecutionSetShaderLayoutInfoEXT(const VkIndirectExecutionSetShaderLayoutInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.setLayoutCount, settings, "uint32_t", "setLayoutCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pSetLayouts, object.setLayoutCount, settings, "const VkDescriptorSetLayout*", "pSetLayouts", "const VkDescriptorSetLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDescriptorSetLayout); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkIndirectExecutionSetShaderInfoEXT(const VkIndirectExecutionSetShaderInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderCount, settings, "uint32_t", "shaderCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pInitialShaders, object.shaderCount, settings, "const VkShaderEXT*", "pInitialShaders", "const VkShaderEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkShaderEXT); + dump_separate_members(settings); + dump_pointer_array(object.pSetLayoutInfos, object.shaderCount, settings, "const VkIndirectExecutionSetShaderLayoutInfoEXT*", "pSetLayoutInfos", "const VkIndirectExecutionSetShaderLayoutInfoEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkIndirectExecutionSetShaderLayoutInfoEXT); + dump_separate_members(settings); + dump_type(object.maxShaderCount, settings, "uint32_t", "maxShaderCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pushConstantRangeCount, settings, "uint32_t", "pushConstantRangeCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pPushConstantRanges, object.pushConstantRangeCount, settings, "const VkPushConstantRange*", "pPushConstantRanges", "const VkPushConstantRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPushConstantRange); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkIndirectExecutionSetInfoEXT(const VkIndirectExecutionSetInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_union, type_name, var_name, indents, address); + if (ApiDumpInstance::current().getIndirectExecutionSetInfoType() == VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT) { + dump_pointer(object.pPipelineInfo, settings, "const VkIndirectExecutionSetPipelineInfoEXT*", "pPipelineInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkIndirectExecutionSetPipelineInfoEXT); + } + dump_separate_members(settings); + if (ApiDumpInstance::current().getIndirectExecutionSetInfoType() == VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT) { + dump_pointer(object.pShaderInfo, settings, "const VkIndirectExecutionSetShaderInfoEXT*", "pShaderInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkIndirectExecutionSetShaderInfoEXT); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkIndirectExecutionSetCreateInfoEXT(const VkIndirectExecutionSetCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkIndirectExecutionSetInfoTypeEXT(object.type, settings, "VkIndirectExecutionSetInfoTypeEXT", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkIndirectExecutionSetInfoEXT(object.info, settings, "VkIndirectExecutionSetInfoEXT", "info", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkGeneratedCommandsInfoEXT(const VkGeneratedCommandsInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkShaderStageFlags(object.shaderStages, settings, "VkShaderStageFlags", "shaderStages", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkIndirectExecutionSetEXT(object.indirectExecutionSet, settings, "VkIndirectExecutionSetEXT", "indirectExecutionSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkIndirectCommandsLayoutEXT(object.indirectCommandsLayout, settings, "VkIndirectCommandsLayoutEXT", "indirectCommandsLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type_hex(object.indirectAddress, settings, "VkDeviceAddress", "indirectAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.indirectAddressSize, settings, "VkDeviceSize", "indirectAddressSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type_hex(object.preprocessAddress, settings, "VkDeviceAddress", "preprocessAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.preprocessSize, settings, "VkDeviceSize", "preprocessSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxSequenceCount, settings, "uint32_t", "maxSequenceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type_hex(object.sequenceCountAddress, settings, "VkDeviceAddress", "sequenceCountAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDrawCount, settings, "uint32_t", "maxDrawCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkWriteIndirectExecutionSetPipelineEXT(const VkWriteIndirectExecutionSetPipelineEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.index, settings, "uint32_t", "index", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipeline(object.pipeline, settings, "VkPipeline", "pipeline", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkIndirectCommandsPushConstantTokenEXT(const VkIndirectCommandsPushConstantTokenEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkPushConstantRange(object.updateRange, settings, "VkPushConstantRange", "updateRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkIndirectCommandsVertexBufferTokenEXT(const VkIndirectCommandsVertexBufferTokenEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.vertexBindingUnit, settings, "uint32_t", "vertexBindingUnit", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkIndirectCommandsIndexBufferTokenEXT(const VkIndirectCommandsIndexBufferTokenEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkIndirectCommandsInputModeFlagBitsEXT(object.mode, settings, "VkIndirectCommandsInputModeFlagBitsEXT", "mode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkIndirectCommandsExecutionSetTokenEXT(const VkIndirectCommandsExecutionSetTokenEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkIndirectExecutionSetInfoTypeEXT(object.type, settings, "VkIndirectExecutionSetInfoTypeEXT", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkShaderStageFlags(object.shaderStages, settings, "VkShaderStageFlags", "shaderStages", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkIndirectCommandsTokenDataEXT(const VkIndirectCommandsTokenDataEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_union, type_name, var_name, indents, address); + if (ApiDumpInstance::current().getIndirectCommandsLayoutToken() == VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT || ApiDumpInstance::current().getIndirectCommandsLayoutToken() == VK_INDIRECT_COMMANDS_TOKEN_TYPE_SEQUENCE_INDEX_EXT) { + dump_pointer(object.pPushConstant, settings, "const VkIndirectCommandsPushConstantTokenEXT*", "pPushConstant", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkIndirectCommandsPushConstantTokenEXT); + } + dump_separate_members(settings); + if (ApiDumpInstance::current().getIndirectCommandsLayoutToken() == VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT) { + dump_pointer(object.pVertexBuffer, settings, "const VkIndirectCommandsVertexBufferTokenEXT*", "pVertexBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkIndirectCommandsVertexBufferTokenEXT); + } + dump_separate_members(settings); + if (ApiDumpInstance::current().getIndirectCommandsLayoutToken() == VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_EXT) { + dump_pointer(object.pIndexBuffer, settings, "const VkIndirectCommandsIndexBufferTokenEXT*", "pIndexBuffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkIndirectCommandsIndexBufferTokenEXT); + } + dump_separate_members(settings); + if (ApiDumpInstance::current().getIndirectCommandsLayoutToken() == VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXECUTION_SET_EXT) { + dump_pointer(object.pExecutionSet, settings, "const VkIndirectCommandsExecutionSetTokenEXT*", "pExecutionSet", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkIndirectCommandsExecutionSetTokenEXT); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkIndirectCommandsLayoutTokenEXT(const VkIndirectCommandsLayoutTokenEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + ApiDumpInstance::current().setIndirectCommandsLayoutToken(object.type); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkIndirectCommandsTokenTypeEXT(object.type, settings, "VkIndirectCommandsTokenTypeEXT", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkIndirectCommandsTokenDataEXT(object.data, settings, "VkIndirectCommandsTokenDataEXT", "data", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.offset, settings, "uint32_t", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkIndirectCommandsLayoutCreateInfoEXT(const VkIndirectCommandsLayoutCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkIndirectCommandsLayoutUsageFlagsEXT(object.flags, settings, "VkIndirectCommandsLayoutUsageFlagsEXT", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkShaderStageFlags(object.shaderStages, settings, "VkShaderStageFlags", "shaderStages", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.indirectStride, settings, "uint32_t", "indirectStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineLayout(object.pipelineLayout, settings, "VkPipelineLayout", "pipelineLayout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.tokenCount, settings, "uint32_t", "tokenCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pTokens, object.tokenCount, settings, "const VkIndirectCommandsLayoutTokenEXT*", "pTokens", "const VkIndirectCommandsLayoutTokenEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkIndirectCommandsLayoutTokenEXT); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDrawIndirectCountIndirectCommandEXT(const VkDrawIndirectCountIndirectCommandEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type_hex(object.bufferAddress, settings, "VkDeviceAddress", "bufferAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.stride, settings, "uint32_t", "stride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.commandCount, settings, "uint32_t", "commandCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBindVertexBufferIndirectCommandEXT(const VkBindVertexBufferIndirectCommandEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type_hex(object.bufferAddress, settings, "VkDeviceAddress", "bufferAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.size, settings, "uint32_t", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.stride, settings, "uint32_t", "stride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBindIndexBufferIndirectCommandEXT(const VkBindIndexBufferIndirectCommandEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type_hex(object.bufferAddress, settings, "VkDeviceAddress", "bufferAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.size, settings, "uint32_t", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkIndexType(object.indexType, settings, "VkIndexType", "indexType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkGeneratedCommandsPipelineInfoEXT(const VkGeneratedCommandsPipelineInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipeline(object.pipeline, settings, "VkPipeline", "pipeline", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkGeneratedCommandsShaderInfoEXT(const VkGeneratedCommandsShaderInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderCount, settings, "uint32_t", "shaderCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pShaders, object.shaderCount, settings, "const VkShaderEXT*", "pShaders", "const VkShaderEXT", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkShaderEXT); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkWriteIndirectExecutionSetShaderEXT(const VkWriteIndirectExecutionSetShaderEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.index, settings, "uint32_t", "index", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkShaderEXT(object.shader, settings, "VkShaderEXT", "shader", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceImageAlignmentControlFeaturesMESA(const VkPhysicalDeviceImageAlignmentControlFeaturesMESA& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.imageAlignmentControl, settings, "VkBool32", "imageAlignmentControl", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceImageAlignmentControlPropertiesMESA(const VkPhysicalDeviceImageAlignmentControlPropertiesMESA& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.supportedImageAlignmentMask, settings, "uint32_t", "supportedImageAlignmentMask", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkImageAlignmentControlCreateInfoMESA(const VkImageAlignmentControlCreateInfoMESA& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maximumRequestedAlignment, settings, "uint32_t", "maximumRequestedAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPushConstantBankInfoNV(const VkPushConstantBankInfoNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.bank, settings, "uint32_t", "bank", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDevicePushConstantBankFeaturesNV(const VkPhysicalDevicePushConstantBankFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pushConstantBank, settings, "VkBool32", "pushConstantBank", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDevicePushConstantBankPropertiesNV(const VkPhysicalDevicePushConstantBankPropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxGraphicsPushConstantBanks, settings, "uint32_t", "maxGraphicsPushConstantBanks", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxComputePushConstantBanks, settings, "uint32_t", "maxComputePushConstantBanks", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxGraphicsPushDataBanks, settings, "uint32_t", "maxGraphicsPushDataBanks", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxComputePushDataBanks, settings, "uint32_t", "maxComputePushDataBanks", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT(const VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkRayTracingInvocationReorderModeEXT(object.rayTracingInvocationReorderReorderingHint, settings, "VkRayTracingInvocationReorderModeEXT", "rayTracingInvocationReorderReorderingHint", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxShaderBindingTableRecordIndex, settings, "uint32_t", "maxShaderBindingTableRecordIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT(const VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.rayTracingInvocationReorder, settings, "VkBool32", "rayTracingInvocationReorder", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceDepthClampControlFeaturesEXT(const VkPhysicalDeviceDepthClampControlFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.depthClampControl, settings, "VkBool32", "depthClampControl", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineViewportDepthClampControlCreateInfoEXT(const VkPipelineViewportDepthClampControlCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDepthClampModeEXT(object.depthClampMode, settings, "VkDepthClampModeEXT", "depthClampMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pDepthClampRange, settings, "const VkDepthClampRangeEXT*", "pDepthClampRange", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkDepthClampRangeEXT); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#if defined(VK_USE_PLATFORM_OHOS) +template +void dump_VkSurfaceCreateInfoOHOS(const VkSurfaceCreateInfoOHOS& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkSurfaceCreateFlagsOHOS(object.flags, settings, "VkSurfaceCreateFlagsOHOS", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.window, settings, "OHNativeWindow*", "window", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#endif // VK_USE_PLATFORM_OHOS +template +void dump_VkPhysicalDeviceHdrVividFeaturesHUAWEI(const VkPhysicalDeviceHdrVividFeaturesHUAWEI& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.hdrVivid, settings, "VkBool32", "hdrVivid", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkHdrVividDynamicMetadataHUAWEI(const VkHdrVividDynamicMetadataHUAWEI& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dynamicMetadataSize, settings, "size_t", "dynamicMetadataSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pDynamicMetadata, settings, "const void*", "pDynamicMetadata", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCooperativeMatrixFlexibleDimensionsPropertiesNV(const VkCooperativeMatrixFlexibleDimensionsPropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.MGranularity, settings, "uint32_t", "MGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.NGranularity, settings, "uint32_t", "NGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.KGranularity, settings, "uint32_t", "KGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkComponentTypeKHR(object.AType, settings, "VkComponentTypeKHR", "AType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkComponentTypeKHR(object.BType, settings, "VkComponentTypeKHR", "BType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkComponentTypeKHR(object.CType, settings, "VkComponentTypeKHR", "CType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkComponentTypeKHR(object.ResultType, settings, "VkComponentTypeKHR", "ResultType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.saturatingAccumulation, settings, "VkBool32", "saturatingAccumulation", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkScopeKHR(object.scope, settings, "VkScopeKHR", "scope", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.workgroupInvocations, settings, "uint32_t", "workgroupInvocations", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceCooperativeMatrix2FeaturesNV(const VkPhysicalDeviceCooperativeMatrix2FeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.cooperativeMatrixWorkgroupScope, settings, "VkBool32", "cooperativeMatrixWorkgroupScope", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.cooperativeMatrixFlexibleDimensions, settings, "VkBool32", "cooperativeMatrixFlexibleDimensions", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.cooperativeMatrixReductions, settings, "VkBool32", "cooperativeMatrixReductions", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.cooperativeMatrixConversions, settings, "VkBool32", "cooperativeMatrixConversions", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.cooperativeMatrixPerElementOperations, settings, "VkBool32", "cooperativeMatrixPerElementOperations", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.cooperativeMatrixTensorAddressing, settings, "VkBool32", "cooperativeMatrixTensorAddressing", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.cooperativeMatrixBlockLoads, settings, "VkBool32", "cooperativeMatrixBlockLoads", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceCooperativeMatrix2PropertiesNV(const VkPhysicalDeviceCooperativeMatrix2PropertiesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.cooperativeMatrixWorkgroupScopeMaxWorkgroupSize, settings, "uint32_t", "cooperativeMatrixWorkgroupScopeMaxWorkgroupSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.cooperativeMatrixFlexibleDimensionsMaxDimension, settings, "uint32_t", "cooperativeMatrixFlexibleDimensionsMaxDimension", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.cooperativeMatrixWorkgroupScopeReservedSharedMemory, settings, "uint32_t", "cooperativeMatrixWorkgroupScopeReservedSharedMemory", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDevicePipelineOpacityMicromapFeaturesARM(const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pipelineOpacityMicromap, settings, "VkBool32", "pipelineOpacityMicromap", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#if defined(VK_USE_PLATFORM_METAL_EXT) +template +void dump_VkImportMemoryMetalHandleInfoEXT(const VkImportMemoryMetalHandleInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalMemoryHandleTypeFlagBits(object.handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.handle, settings, "void*", "handle", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMemoryMetalHandlePropertiesEXT(const VkMemoryMetalHandlePropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.memoryTypeBits, settings, "uint32_t", "memoryTypeBits", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkMemoryGetMetalHandleInfoEXT(const VkMemoryGetMetalHandleInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceMemory(object.memory, settings, "VkDeviceMemory", "memory", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExternalMemoryHandleTypeFlagBits(object.handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#endif // VK_USE_PLATFORM_METAL_EXT +template +void dump_VkPhysicalDevicePerformanceCountersByRegionFeaturesARM(const VkPhysicalDevicePerformanceCountersByRegionFeaturesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.performanceCountersByRegion, settings, "VkBool32", "performanceCountersByRegion", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDevicePerformanceCountersByRegionPropertiesARM(const VkPhysicalDevicePerformanceCountersByRegionPropertiesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPerRegionPerformanceCounters, settings, "uint32_t", "maxPerRegionPerformanceCounters", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkExtent2D(object.performanceCounterRegionSize, settings, "VkExtent2D", "performanceCounterRegionSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.rowStrideAlignment, settings, "uint32_t", "rowStrideAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.regionAlignment, settings, "uint32_t", "regionAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.identityTransformOrder, settings, "VkBool32", "identityTransformOrder", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPerformanceCounterARM(const VkPerformanceCounterARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.counterID, settings, "uint32_t", "counterID", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPerformanceCounterDescriptionARM(const VkPerformanceCounterDescriptionARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPerformanceCounterDescriptionFlagsARM(object.flags, settings, "VkPerformanceCounterDescriptionFlagsARM", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_char(object.name, settings, "char[VK_MAX_DESCRIPTION_SIZE]", "name", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkRenderPassPerformanceCountersByRegionBeginInfoARM(const VkRenderPassPerformanceCountersByRegionBeginInfoARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.counterAddressCount, settings, "uint32_t", "counterAddressCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pCounterAddresses, settings, "const VkDeviceAddress*", "pCounterAddresses", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.serializeRegions, settings, "VkBool32", "serializeRegions", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.counterIndexCount, settings, "uint32_t", "counterIndexCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pCounterIndices, settings, "uint32_t*", "pCounterIndices", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT(const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vertexAttributeRobustness, settings, "VkBool32", "vertexAttributeRobustness", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceFormatPackFeaturesARM(const VkPhysicalDeviceFormatPackFeaturesARM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.formatPack, settings, "VkBool32", "formatPack", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE(const VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.fragmentDensityMapLayered, settings, "VkBool32", "fragmentDensityMapLayered", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE(const VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxFragmentDensityMapLayers, settings, "uint32_t", "maxFragmentDensityMapLayers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineFragmentDensityMapLayeredCreateInfoVALVE(const VkPipelineFragmentDensityMapLayeredCreateInfoVALVE& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxFragmentDensityMapLayers, settings, "uint32_t", "maxFragmentDensityMapLayers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#if defined(VK_ENABLE_BETA_EXTENSIONS) +template +void dump_VkSetPresentConfigNV(const VkSetPresentConfigNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.numFramesPerBatch, settings, "uint32_t", "numFramesPerBatch", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.presentConfigFeedback, settings, "uint32_t", "presentConfigFeedback", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDevicePresentMeteringFeaturesNV(const VkPhysicalDevicePresentMeteringFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.presentMetering, settings, "VkBool32", "presentMetering", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +#endif // VK_ENABLE_BETA_EXTENSIONS +template +void dump_VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT(const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.zeroInitializeDeviceMemory, settings, "VkBool32", "zeroInitializeDeviceMemory", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShader64BitIndexingFeaturesEXT(const VkPhysicalDeviceShader64BitIndexingFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shader64BitIndexing, settings, "VkBool32", "shader64BitIndexing", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceCustomResolveFeaturesEXT(const VkPhysicalDeviceCustomResolveFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.customResolve, settings, "VkBool32", "customResolve", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkBeginCustomResolveInfoEXT(const VkBeginCustomResolveInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCustomResolveCreateInfoEXT(const VkCustomResolveCreateInfoEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.customResolve, settings, "VkBool32", "customResolve", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.colorAttachmentCount, settings, "uint32_t", "colorAttachmentCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pColorAttachmentFormats, object.colorAttachmentCount, settings, "const VkFormat*", "pColorAttachmentFormats", "const VkFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkFormat); + dump_separate_members(settings); + dump_VkFormat(object.depthAttachmentFormat, settings, "VkFormat", "depthAttachmentFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormat(object.stencilAttachmentFormat, settings, "VkFormat", "stencilAttachmentFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPipelineCacheHeaderVersionDataGraphQCOM(const VkPipelineCacheHeaderVersionDataGraphQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.headerSize, settings, "uint32_t", "headerSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineCacheHeaderVersion(object.headerVersion, settings, "VkPipelineCacheHeaderVersion", "headerVersion", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDataGraphModelCacheTypeQCOM(object.cacheType, settings, "VkDataGraphModelCacheTypeQCOM", "cacheType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.cacheVersion, settings, "uint32_t", "cacheVersion", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.toolchainVersion, VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM, settings, "uint32_t[VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM]", "toolchainVersion", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDataGraphPipelineBuiltinModelCreateInfoQCOM(const VkDataGraphPipelineBuiltinModelCreateInfoQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pOperation, settings, "const VkPhysicalDeviceDataGraphOperationSupportARM*", "pOperation", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPhysicalDeviceDataGraphOperationSupportARM); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceDataGraphModelFeaturesQCOM(const VkPhysicalDeviceDataGraphModelFeaturesQCOM& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.dataGraphModel, settings, "VkBool32", "dataGraphModel", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderLongVectorFeaturesEXT(const VkPhysicalDeviceShaderLongVectorFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.longVector, settings, "VkBool32", "longVector", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderLongVectorPropertiesEXT(const VkPhysicalDeviceShaderLongVectorPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxVectorComponents, settings, "uint32_t", "maxVectorComponents", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC(const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pipelineCacheIncrementalMode, settings, "VkBool32", "pipelineCacheIncrementalMode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT(const VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderUniformBufferUnsizedArray, settings, "VkBool32", "shaderUniformBufferUnsizedArray", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkComputeOccupancyPriorityParametersNV(const VkComputeOccupancyPriorityParametersNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.occupancyPriority, settings, "float", "occupancyPriority", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.occupancyThrottling, settings, "float", "occupancyThrottling", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV(const VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.computeOccupancyPriority, settings, "VkBool32", "computeOccupancyPriority", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT(const VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderSubgroupPartitioned, settings, "VkBool32", "shaderSubgroupPartitioned", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAccelerationStructureBuildRangeInfoKHR(const VkAccelerationStructureBuildRangeInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.primitiveCount, settings, "uint32_t", "primitiveCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.primitiveOffset, settings, "uint32_t", "primitiveOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.firstVertex, settings, "uint32_t", "firstVertex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.transformOffset, settings, "uint32_t", "transformOffset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAccelerationStructureGeometryTrianglesDataKHR(const VkAccelerationStructureGeometryTrianglesDataKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkFormat(object.vertexFormat, settings, "VkFormat", "vertexFormat", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceOrHostAddressConstKHR(object.vertexData, settings, "VkDeviceOrHostAddressConstKHR", "vertexData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.vertexStride, settings, "VkDeviceSize", "vertexStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxVertex, settings, "uint32_t", "maxVertex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkIndexType(object.indexType, settings, "VkIndexType", "indexType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceOrHostAddressConstKHR(object.indexData, settings, "VkDeviceOrHostAddressConstKHR", "indexData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceOrHostAddressConstKHR(object.transformData, settings, "VkDeviceOrHostAddressConstKHR", "transformData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAccelerationStructureGeometryAabbsDataKHR(const VkAccelerationStructureGeometryAabbsDataKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceOrHostAddressConstKHR(object.data, settings, "VkDeviceOrHostAddressConstKHR", "data", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.stride, settings, "VkDeviceSize", "stride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAccelerationStructureGeometryInstancesDataKHR(const VkAccelerationStructureGeometryInstancesDataKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.arrayOfPointers, settings, "VkBool32", "arrayOfPointers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceOrHostAddressConstKHR(object.data, settings, "VkDeviceOrHostAddressConstKHR", "data", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAccelerationStructureGeometryDataKHR(const VkAccelerationStructureGeometryDataKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_union, type_name, var_name, indents, address); + dump_VkAccelerationStructureGeometryTrianglesDataKHR(object.triangles, settings, "VkAccelerationStructureGeometryTrianglesDataKHR", "triangles", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccelerationStructureGeometryAabbsDataKHR(object.aabbs, settings, "VkAccelerationStructureGeometryAabbsDataKHR", "aabbs", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccelerationStructureGeometryInstancesDataKHR(object.instances, settings, "VkAccelerationStructureGeometryInstancesDataKHR", "instances", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAccelerationStructureGeometryKHR(const VkAccelerationStructureGeometryKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkGeometryTypeKHR(object.geometryType, settings, "VkGeometryTypeKHR", "geometryType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccelerationStructureGeometryDataKHR(object.geometry, settings, "VkAccelerationStructureGeometryDataKHR", "geometry", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkGeometryFlagsKHR(object.flags, settings, "VkGeometryFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAccelerationStructureBuildGeometryInfoKHR(const VkAccelerationStructureBuildGeometryInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccelerationStructureTypeKHR(object.type, settings, "VkAccelerationStructureTypeKHR", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBuildAccelerationStructureFlagsKHR(object.flags, settings, "VkBuildAccelerationStructureFlagsKHR", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBuildAccelerationStructureModeKHR(object.mode, settings, "VkBuildAccelerationStructureModeKHR", "mode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccelerationStructureKHR(object.srcAccelerationStructure, settings, "VkAccelerationStructureKHR", "srcAccelerationStructure", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccelerationStructureKHR(object.dstAccelerationStructure, settings, "VkAccelerationStructureKHR", "dstAccelerationStructure", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.geometryCount, settings, "uint32_t", "geometryCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pGeometries, object.geometryCount, settings, "const VkAccelerationStructureGeometryKHR*", "pGeometries", "const VkAccelerationStructureGeometryKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkAccelerationStructureGeometryKHR); + dump_separate_members(settings); + dump_double_pointer_array(object.ppGeometries, object.geometryCount * 1, settings, "const VkAccelerationStructureGeometryKHR* const*", "ppGeometries", "const VkAccelerationStructureGeometryKHR*", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkAccelerationStructureGeometryKHR); + dump_separate_members(settings); + dump_VkDeviceOrHostAddressKHR(object.scratchData, settings, "VkDeviceOrHostAddressKHR", "scratchData", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAccelerationStructureCreateInfoKHR(const VkAccelerationStructureCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccelerationStructureCreateFlagsKHR(object.createFlags, settings, "VkAccelerationStructureCreateFlagsKHR", "createFlags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkBuffer(object.buffer, settings, "VkBuffer", "buffer", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.offset, settings, "VkDeviceSize", "offset", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.size, settings, "VkDeviceSize", "size", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccelerationStructureTypeKHR(object.type, settings, "VkAccelerationStructureTypeKHR", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type_hex(object.deviceAddress, settings, "VkDeviceAddress", "deviceAddress", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkWriteDescriptorSetAccelerationStructureKHR(const VkWriteDescriptorSetAccelerationStructureKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.accelerationStructureCount, settings, "uint32_t", "accelerationStructureCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pAccelerationStructures, object.accelerationStructureCount, settings, "const VkAccelerationStructureKHR*", "pAccelerationStructures", "const VkAccelerationStructureKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkAccelerationStructureKHR); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceAccelerationStructureFeaturesKHR(const VkPhysicalDeviceAccelerationStructureFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.accelerationStructure, settings, "VkBool32", "accelerationStructure", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.accelerationStructureCaptureReplay, settings, "VkBool32", "accelerationStructureCaptureReplay", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.accelerationStructureIndirectBuild, settings, "VkBool32", "accelerationStructureIndirectBuild", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.accelerationStructureHostCommands, settings, "VkBool32", "accelerationStructureHostCommands", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.descriptorBindingAccelerationStructureUpdateAfterBind, settings, "VkBool32", "descriptorBindingAccelerationStructureUpdateAfterBind", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceAccelerationStructurePropertiesKHR(const VkPhysicalDeviceAccelerationStructurePropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxGeometryCount, settings, "uint64_t", "maxGeometryCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxInstanceCount, settings, "uint64_t", "maxInstanceCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPrimitiveCount, settings, "uint64_t", "maxPrimitiveCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPerStageDescriptorAccelerationStructures, settings, "uint32_t", "maxPerStageDescriptorAccelerationStructures", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPerStageDescriptorUpdateAfterBindAccelerationStructures, settings, "uint32_t", "maxPerStageDescriptorUpdateAfterBindAccelerationStructures", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDescriptorSetAccelerationStructures, settings, "uint32_t", "maxDescriptorSetAccelerationStructures", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxDescriptorSetUpdateAfterBindAccelerationStructures, settings, "uint32_t", "maxDescriptorSetUpdateAfterBindAccelerationStructures", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.minAccelerationStructureScratchOffsetAlignment, settings, "uint32_t", "minAccelerationStructureScratchOffsetAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAccelerationStructureDeviceAddressInfoKHR(const VkAccelerationStructureDeviceAddressInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccelerationStructureKHR(object.accelerationStructure, settings, "VkAccelerationStructureKHR", "accelerationStructure", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkAccelerationStructureVersionInfoKHR(const VkAccelerationStructureVersionInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pVersionData, 2 * VK_UUID_SIZE, settings, "const uint8_t*", "pVersionData", "const uint8_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCopyAccelerationStructureToMemoryInfoKHR(const VkCopyAccelerationStructureToMemoryInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccelerationStructureKHR(object.src, settings, "VkAccelerationStructureKHR", "src", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceOrHostAddressKHR(object.dst, settings, "VkDeviceOrHostAddressKHR", "dst", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkCopyAccelerationStructureModeKHR(object.mode, settings, "VkCopyAccelerationStructureModeKHR", "mode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCopyMemoryToAccelerationStructureInfoKHR(const VkCopyMemoryToAccelerationStructureInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkDeviceOrHostAddressConstKHR(object.src, settings, "VkDeviceOrHostAddressConstKHR", "src", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccelerationStructureKHR(object.dst, settings, "VkAccelerationStructureKHR", "dst", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkCopyAccelerationStructureModeKHR(object.mode, settings, "VkCopyAccelerationStructureModeKHR", "mode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkCopyAccelerationStructureInfoKHR(const VkCopyAccelerationStructureInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccelerationStructureKHR(object.src, settings, "VkAccelerationStructureKHR", "src", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkAccelerationStructureKHR(object.dst, settings, "VkAccelerationStructureKHR", "dst", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkCopyAccelerationStructureModeKHR(object.mode, settings, "VkCopyAccelerationStructureModeKHR", "mode", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkRayTracingShaderGroupCreateInfoKHR(const VkRayTracingShaderGroupCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkRayTracingShaderGroupTypeKHR(object.type, settings, "VkRayTracingShaderGroupTypeKHR", "type", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.generalShader, settings, "uint32_t", "generalShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.closestHitShader, settings, "uint32_t", "closestHitShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.anyHitShader, settings, "uint32_t", "anyHitShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.intersectionShader, settings, "uint32_t", "intersectionShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.pShaderGroupCaptureReplayHandle, settings, "const void*", "pShaderGroupCaptureReplayHandle", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkRayTracingPipelineInterfaceCreateInfoKHR(const VkRayTracingPipelineInterfaceCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPipelineRayPayloadSize, settings, "uint32_t", "maxPipelineRayPayloadSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPipelineRayHitAttributeSize, settings, "uint32_t", "maxPipelineRayHitAttributeSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkRayTracingPipelineCreateInfoKHR(const VkRayTracingPipelineCreateInfoKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "const void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipelineCreateFlags(object.flags, settings, "VkPipelineCreateFlags", "flags", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.stageCount, settings, "uint32_t", "stageCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pStages, object.stageCount, settings, "const VkPipelineShaderStageCreateInfo*", "pStages", "const VkPipelineShaderStageCreateInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineShaderStageCreateInfo); + dump_separate_members(settings); + dump_type(object.groupCount, settings, "uint32_t", "groupCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer_array(object.pGroups, object.groupCount, settings, "const VkRayTracingShaderGroupCreateInfoKHR*", "pGroups", "const VkRayTracingShaderGroupCreateInfoKHR", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkRayTracingShaderGroupCreateInfoKHR); + dump_separate_members(settings); + dump_type(object.maxPipelineRayRecursionDepth, settings, "uint32_t", "maxPipelineRayRecursionDepth", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pointer(object.pLibraryInfo, settings, "const VkPipelineLibraryCreateInfoKHR*", "pLibraryInfo", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineLibraryCreateInfoKHR); + dump_separate_members(settings); + dump_pointer(object.pLibraryInterface, settings, "const VkRayTracingPipelineInterfaceCreateInfoKHR*", "pLibraryInterface", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkRayTracingPipelineInterfaceCreateInfoKHR); + dump_separate_members(settings); + dump_pointer(object.pDynamicState, settings, "const VkPipelineDynamicStateCreateInfo*", "pDynamicState", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_VkPipelineDynamicStateCreateInfo); + dump_separate_members(settings); + dump_VkPipelineLayout(object.layout, settings, "VkPipelineLayout", "layout", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_VkPipeline(object.basePipelineHandle, settings, "VkPipeline", "basePipelineHandle", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.basePipelineIndex, settings, "int32_t", "basePipelineIndex", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "const void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(const VkPhysicalDeviceRayTracingPipelineFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.rayTracingPipeline, settings, "VkBool32", "rayTracingPipeline", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.rayTracingPipelineShaderGroupHandleCaptureReplay, settings, "VkBool32", "rayTracingPipelineShaderGroupHandleCaptureReplay", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.rayTracingPipelineShaderGroupHandleCaptureReplayMixed, settings, "VkBool32", "rayTracingPipelineShaderGroupHandleCaptureReplayMixed", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.rayTracingPipelineTraceRaysIndirect, settings, "VkBool32", "rayTracingPipelineTraceRaysIndirect", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.rayTraversalPrimitiveCulling, settings, "VkBool32", "rayTraversalPrimitiveCulling", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(const VkPhysicalDeviceRayTracingPipelinePropertiesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderGroupHandleSize, settings, "uint32_t", "shaderGroupHandleSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxRayRecursionDepth, settings, "uint32_t", "maxRayRecursionDepth", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxShaderGroupStride, settings, "uint32_t", "maxShaderGroupStride", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderGroupBaseAlignment, settings, "uint32_t", "shaderGroupBaseAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderGroupHandleCaptureReplaySize, settings, "uint32_t", "shaderGroupHandleCaptureReplaySize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxRayDispatchInvocationCount, settings, "uint32_t", "maxRayDispatchInvocationCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.shaderGroupHandleAlignment, settings, "uint32_t", "shaderGroupHandleAlignment", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxRayHitAttributeSize, settings, "uint32_t", "maxRayHitAttributeSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkTraceRaysIndirectCommandKHR(const VkTraceRaysIndirectCommandKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.width, settings, "uint32_t", "width", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.height, settings, "uint32_t", "height", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.depth, settings, "uint32_t", "depth", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceRayQueryFeaturesKHR(const VkPhysicalDeviceRayQueryFeaturesKHR& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.rayQuery, settings, "VkBool32", "rayQuery", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceMeshShaderFeaturesEXT(const VkPhysicalDeviceMeshShaderFeaturesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.taskShader, settings, "VkBool32", "taskShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.meshShader, settings, "VkBool32", "meshShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.multiviewMeshShader, settings, "VkBool32", "multiviewMeshShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.primitiveFragmentShadingRateMeshShader, settings, "VkBool32", "primitiveFragmentShadingRateMeshShader", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.meshShaderQueries, settings, "VkBool32", "meshShaderQueries", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkPhysicalDeviceMeshShaderPropertiesEXT(const VkPhysicalDeviceMeshShaderPropertiesEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_VkStructureType(object.sType, settings, "VkStructureType", "sType", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_pNext(object.pNext, settings, "void*", "pNext", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxTaskWorkGroupTotalCount, settings, "uint32_t", "maxTaskWorkGroupTotalCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.maxTaskWorkGroupCount, 3, settings, "uint32_t[3]", "maxTaskWorkGroupCount", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.maxTaskWorkGroupInvocations, settings, "uint32_t", "maxTaskWorkGroupInvocations", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.maxTaskWorkGroupSize, 3, settings, "uint32_t[3]", "maxTaskWorkGroupSize", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.maxTaskPayloadSize, settings, "uint32_t", "maxTaskPayloadSize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxTaskSharedMemorySize, settings, "uint32_t", "maxTaskSharedMemorySize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxTaskPayloadAndSharedMemorySize, settings, "uint32_t", "maxTaskPayloadAndSharedMemorySize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxMeshWorkGroupTotalCount, settings, "uint32_t", "maxMeshWorkGroupTotalCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.maxMeshWorkGroupCount, 3, settings, "uint32_t[3]", "maxMeshWorkGroupCount", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.maxMeshWorkGroupInvocations, settings, "uint32_t", "maxMeshWorkGroupInvocations", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_single_array(object.maxMeshWorkGroupSize, 3, settings, "uint32_t[3]", "maxMeshWorkGroupSize", "uint32_t", indents + (Format == ApiDumpFormat::Json ? 2 : 1), dump_type); + dump_separate_members(settings); + dump_type(object.maxMeshSharedMemorySize, settings, "uint32_t", "maxMeshSharedMemorySize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxMeshPayloadAndSharedMemorySize, settings, "uint32_t", "maxMeshPayloadAndSharedMemorySize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxMeshOutputMemorySize, settings, "uint32_t", "maxMeshOutputMemorySize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxMeshPayloadAndOutputMemorySize, settings, "uint32_t", "maxMeshPayloadAndOutputMemorySize", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxMeshOutputComponents, settings, "uint32_t", "maxMeshOutputComponents", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxMeshOutputVertices, settings, "uint32_t", "maxMeshOutputVertices", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxMeshOutputPrimitives, settings, "uint32_t", "maxMeshOutputPrimitives", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxMeshOutputLayers, settings, "uint32_t", "maxMeshOutputLayers", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxMeshMultiviewViewCount, settings, "uint32_t", "maxMeshMultiviewViewCount", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.meshOutputPerVertexGranularity, settings, "uint32_t", "meshOutputPerVertexGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.meshOutputPerPrimitiveGranularity, settings, "uint32_t", "meshOutputPerPrimitiveGranularity", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPreferredTaskWorkGroupInvocations, settings, "uint32_t", "maxPreferredTaskWorkGroupInvocations", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.maxPreferredMeshWorkGroupInvocations, settings, "uint32_t", "maxPreferredMeshWorkGroupInvocations", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.prefersLocalInvocationVertexOutput, settings, "VkBool32", "prefersLocalInvocationVertexOutput", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.prefersLocalInvocationPrimitiveOutput, settings, "VkBool32", "prefersLocalInvocationPrimitiveOutput", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.prefersCompactVertexOutput, settings, "VkBool32", "prefersCompactVertexOutput", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.prefersCompactPrimitiveOutput, settings, "VkBool32", "prefersCompactPrimitiveOutput", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + if constexpr (Format == ApiDumpFormat::Text) { + dump_pNext_trampoline(object.pNext, settings, "void*", "void", indents < 2 ? indents + 1 : indents); + } + dump_end(settings, OutputConstruct::api_struct, indents); +} +template +void dump_VkDrawMeshTasksIndirectCommandEXT(const VkDrawMeshTasksIndirectCommandEXT& object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents, const void* address = nullptr) { + dump_start(settings, OutputConstruct::api_struct, type_name, var_name, indents, address); + dump_type(object.groupCountX, settings, "uint32_t", "groupCountX", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.groupCountY, settings, "uint32_t", "groupCountY", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_separate_members(settings); + dump_type(object.groupCountZ, settings, "uint32_t", "groupCountZ", indents + (Format == ApiDumpFormat::Json ? 2 : 1)); + dump_end(settings, OutputConstruct::api_struct, indents); +} + +//======================== pNext Chain Implementation =======================// + +template +void dump_pNext_struct_name(const void* object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents) { + if (object == nullptr) { + dump_nullptr(settings, type_name, var_name, indents); + return; + } + VkBaseInStructure base_struct{}; + memcpy(&base_struct, object, sizeof(VkBaseInStructure)); + if (base_struct.sType == VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO || base_struct.sType == VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO) { + if (base_struct.pNext != nullptr) { + dump_pNext_struct_name(base_struct.pNext, settings, type_name, var_name, indents); + } else { + dump_nullptr(settings, "const void*", "pNext", indents); + } + return; + } + dump_start(settings, OutputConstruct::value, type_name, var_name, indents); + switch (base_struct.sType) { + case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER: + dump_string(settings, "VkBufferMemoryBarrier"); + break; + + case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER: + dump_string(settings, "VkImageMemoryBarrier"); + break; + + case VK_STRUCTURE_TYPE_MEMORY_BARRIER: + dump_string(settings, "VkMemoryBarrier"); + break; + + case VK_STRUCTURE_TYPE_APPLICATION_INFO: + dump_string(settings, "VkApplicationInfo"); + break; + + case VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO: + dump_string(settings, "VkInstanceCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO: + dump_string(settings, "VkDeviceQueueCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO: + dump_string(settings, "VkDeviceCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_SUBMIT_INFO: + dump_string(settings, "VkSubmitInfo"); + break; + + case VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE: + dump_string(settings, "VkMappedMemoryRange"); + break; + + case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: + dump_string(settings, "VkMemoryAllocateInfo"); + break; + + case VK_STRUCTURE_TYPE_BIND_SPARSE_INFO: + dump_string(settings, "VkBindSparseInfo"); + break; + + case VK_STRUCTURE_TYPE_FENCE_CREATE_INFO: + dump_string(settings, "VkFenceCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO: + dump_string(settings, "VkSemaphoreCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO: + dump_string(settings, "VkQueryPoolCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO: + dump_string(settings, "VkBufferCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO: + dump_string(settings, "VkImageCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO: + dump_string(settings, "VkImageViewCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO: + dump_string(settings, "VkCommandPoolCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO: + dump_string(settings, "VkCommandBufferAllocateInfo"); + break; + + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO: + dump_string(settings, "VkCommandBufferInheritanceInfo"); + break; + + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO: + dump_string(settings, "VkCommandBufferBeginInfo"); + break; + + case VK_STRUCTURE_TYPE_EVENT_CREATE_INFO: + dump_string(settings, "VkEventCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO: + dump_string(settings, "VkBufferViewCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: + dump_string(settings, "VkShaderModuleCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO: + dump_string(settings, "VkPipelineCacheCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO: + dump_string(settings, "VkPipelineShaderStageCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO: + dump_string(settings, "VkComputePipelineCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: + dump_string(settings, "VkPipelineLayoutCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO: + dump_string(settings, "VkSamplerCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET: + dump_string(settings, "VkCopyDescriptorSet"); + break; + + case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO: + dump_string(settings, "VkDescriptorPoolCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO: + dump_string(settings, "VkDescriptorSetAllocateInfo"); + break; + + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO: + dump_string(settings, "VkDescriptorSetLayoutCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET: + dump_string(settings, "VkWriteDescriptorSet"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO: + dump_string(settings, "VkPipelineVertexInputStateCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO: + dump_string(settings, "VkPipelineInputAssemblyStateCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO: + dump_string(settings, "VkPipelineTessellationStateCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO: + dump_string(settings, "VkPipelineViewportStateCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO: + dump_string(settings, "VkPipelineRasterizationStateCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO: + dump_string(settings, "VkPipelineMultisampleStateCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO: + dump_string(settings, "VkPipelineDepthStencilStateCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO: + dump_string(settings, "VkPipelineColorBlendStateCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO: + dump_string(settings, "VkPipelineDynamicStateCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO: + dump_string(settings, "VkGraphicsPipelineCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO: + dump_string(settings, "VkFramebufferCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO: + dump_string(settings, "VkRenderPassCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO: + dump_string(settings, "VkRenderPassBeginInfo"); + break; + + case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO: + dump_string(settings, "VkBindBufferMemoryInfo"); + break; + + case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO: + dump_string(settings, "VkBindImageMemoryInfo"); + break; + + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: + dump_string(settings, "VkMemoryDedicatedRequirements"); + break; + + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: + dump_string(settings, "VkMemoryDedicatedAllocateInfo"); + break; + + case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO: + dump_string(settings, "VkMemoryAllocateFlagsInfo"); + break; + + case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: + dump_string(settings, "VkDeviceGroupCommandBufferBeginInfo"); + break; + + case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO: + dump_string(settings, "VkDeviceGroupSubmitInfo"); + break; + + case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO: + dump_string(settings, "VkDeviceGroupBindSparseInfo"); + break; + + case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: + dump_string(settings, "VkBindBufferMemoryDeviceGroupInfo"); + break; + + case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: + dump_string(settings, "VkBindImageMemoryDeviceGroupInfo"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES: + dump_string(settings, "VkPhysicalDeviceGroupProperties"); + break; + + case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO: + dump_string(settings, "VkDeviceGroupDeviceCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2: + dump_string(settings, "VkBufferMemoryRequirementsInfo2"); + break; + + case VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2: + dump_string(settings, "VkImageMemoryRequirementsInfo2"); + break; + + case VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2: + dump_string(settings, "VkImageSparseMemoryRequirementsInfo2"); + break; + + case VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2: + dump_string(settings, "VkMemoryRequirements2"); + break; + + case VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2: + dump_string(settings, "VkSparseImageMemoryRequirements2"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: + dump_string(settings, "VkPhysicalDeviceFeatures2"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2: + dump_string(settings, "VkPhysicalDeviceProperties2"); + break; + + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2: + dump_string(settings, "VkFormatProperties2"); + break; + + case VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2: + dump_string(settings, "VkImageFormatProperties2"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2: + dump_string(settings, "VkPhysicalDeviceImageFormatInfo2"); + break; + + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2: + dump_string(settings, "VkQueueFamilyProperties2"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2: + dump_string(settings, "VkPhysicalDeviceMemoryProperties2"); + break; + + case VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2: + dump_string(settings, "VkSparseImageFormatProperties2"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2: + dump_string(settings, "VkPhysicalDeviceSparseImageFormatInfo2"); + break; + + case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO: + dump_string(settings, "VkImageViewUsageCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: + dump_string(settings, "VkPhysicalDeviceProtectedMemoryFeatures"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: + dump_string(settings, "VkPhysicalDeviceProtectedMemoryProperties"); + break; + + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2: + dump_string(settings, "VkDeviceQueueInfo2"); + break; + + case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO: + dump_string(settings, "VkProtectedSubmitInfo"); + break; + + case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO: + dump_string(settings, "VkBindImagePlaneMemoryInfo"); + break; + + case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: + dump_string(settings, "VkImagePlaneMemoryRequirementsInfo"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: + dump_string(settings, "VkPhysicalDeviceExternalImageFormatInfo"); + break; + + case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES: + dump_string(settings, "VkExternalImageFormatProperties"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO: + dump_string(settings, "VkPhysicalDeviceExternalBufferInfo"); + break; + + case VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES: + dump_string(settings, "VkExternalBufferProperties"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: + dump_string(settings, "VkPhysicalDeviceIDProperties"); + break; + + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: + dump_string(settings, "VkExternalMemoryImageCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: + dump_string(settings, "VkExternalMemoryBufferCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO: + dump_string(settings, "VkExportMemoryAllocateInfo"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO: + dump_string(settings, "VkPhysicalDeviceExternalFenceInfo"); + break; + + case VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES: + dump_string(settings, "VkExternalFenceProperties"); + break; + + case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO: + dump_string(settings, "VkExportFenceCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO: + dump_string(settings, "VkExportSemaphoreCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO: + dump_string(settings, "VkPhysicalDeviceExternalSemaphoreInfo"); + break; + + case VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES: + dump_string(settings, "VkExternalSemaphoreProperties"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: + dump_string(settings, "VkPhysicalDeviceSubgroupProperties"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: + dump_string(settings, "VkPhysicalDevice16BitStorageFeatures"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: + dump_string(settings, "VkPhysicalDeviceVariablePointersFeatures"); + break; + + case VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO: + dump_string(settings, "VkDescriptorUpdateTemplateCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: + dump_string(settings, "VkPhysicalDeviceMaintenance3Properties"); + break; + + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT: + dump_string(settings, "VkDescriptorSetLayoutSupport"); + break; + + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO: + dump_string(settings, "VkSamplerYcbcrConversionCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: + dump_string(settings, "VkSamplerYcbcrConversionInfo"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: + dump_string(settings, "VkPhysicalDeviceSamplerYcbcrConversionFeatures"); + break; + + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: + dump_string(settings, "VkSamplerYcbcrConversionImageFormatProperties"); + break; + + case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: + dump_string(settings, "VkDeviceGroupRenderPassBeginInfo"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: + dump_string(settings, "VkPhysicalDevicePointClippingProperties"); + break; + + case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: + dump_string(settings, "VkRenderPassInputAttachmentAspectCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: + dump_string(settings, "VkPipelineTessellationDomainOriginStateCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO: + dump_string(settings, "VkRenderPassMultiviewCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: + dump_string(settings, "VkPhysicalDeviceMultiviewFeatures"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: + dump_string(settings, "VkPhysicalDeviceMultiviewProperties"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: + dump_string(settings, "VkPhysicalDeviceShaderDrawParametersFeatures"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + dump_string(settings, "VkPhysicalDeviceVulkan11Features"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: + dump_string(settings, "VkPhysicalDeviceVulkan11Properties"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + dump_string(settings, "VkPhysicalDeviceVulkan12Features"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: + dump_string(settings, "VkPhysicalDeviceVulkan12Properties"); + break; + + case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: + dump_string(settings, "VkImageFormatListCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES: + dump_string(settings, "VkPhysicalDeviceDriverProperties"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: + dump_string(settings, "VkPhysicalDeviceVulkanMemoryModelFeatures"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: + dump_string(settings, "VkPhysicalDeviceHostQueryResetFeatures"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: + dump_string(settings, "VkPhysicalDeviceTimelineSemaphoreFeatures"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: + dump_string(settings, "VkPhysicalDeviceTimelineSemaphoreProperties"); + break; + + case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO: + dump_string(settings, "VkSemaphoreTypeCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO: + dump_string(settings, "VkTimelineSemaphoreSubmitInfo"); + break; + + case VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO: + dump_string(settings, "VkSemaphoreWaitInfo"); + break; + + case VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO: + dump_string(settings, "VkSemaphoreSignalInfo"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: + dump_string(settings, "VkPhysicalDeviceBufferDeviceAddressFeatures"); + break; + + case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO: + dump_string(settings, "VkBufferDeviceAddressInfo"); + break; + + case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: + dump_string(settings, "VkBufferOpaqueCaptureAddressCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO: + dump_string(settings, "VkMemoryOpaqueCaptureAddressAllocateInfo"); + break; + + case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO: + dump_string(settings, "VkDeviceMemoryOpaqueCaptureAddressInfo"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: + dump_string(settings, "VkPhysicalDevice8BitStorageFeatures"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: + dump_string(settings, "VkPhysicalDeviceShaderAtomicInt64Features"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: + dump_string(settings, "VkPhysicalDeviceShaderFloat16Int8Features"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: + dump_string(settings, "VkPhysicalDeviceFloatControlsProperties"); + break; + + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO: + dump_string(settings, "VkDescriptorSetLayoutBindingFlagsCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: + dump_string(settings, "VkPhysicalDeviceDescriptorIndexingFeatures"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: + dump_string(settings, "VkPhysicalDeviceDescriptorIndexingProperties"); + break; + + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO: + dump_string(settings, "VkDescriptorSetVariableDescriptorCountAllocateInfo"); + break; + + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT: + dump_string(settings, "VkDescriptorSetVariableDescriptorCountLayoutSupport"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: + dump_string(settings, "VkPhysicalDeviceScalarBlockLayoutFeatures"); + break; + + case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO: + dump_string(settings, "VkSamplerReductionModeCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: + dump_string(settings, "VkPhysicalDeviceSamplerFilterMinmaxProperties"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: + dump_string(settings, "VkPhysicalDeviceUniformBufferStandardLayoutFeatures"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: + dump_string(settings, "VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures"); + break; + + case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2: + dump_string(settings, "VkAttachmentDescription2"); + break; + + case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2: + dump_string(settings, "VkAttachmentReference2"); + break; + + case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2: + dump_string(settings, "VkSubpassDescription2"); + break; + + case VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2: + dump_string(settings, "VkSubpassDependency2"); + break; + + case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2: + dump_string(settings, "VkRenderPassCreateInfo2"); + break; + + case VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO: + dump_string(settings, "VkSubpassBeginInfo"); + break; + + case VK_STRUCTURE_TYPE_SUBPASS_END_INFO: + dump_string(settings, "VkSubpassEndInfo"); + break; + + case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE: + dump_string(settings, "VkSubpassDescriptionDepthStencilResolve"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: + dump_string(settings, "VkPhysicalDeviceDepthStencilResolveProperties"); + break; + + case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: + dump_string(settings, "VkImageStencilUsageCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: + dump_string(settings, "VkPhysicalDeviceImagelessFramebufferFeatures"); + break; + + case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO: + dump_string(settings, "VkFramebufferAttachmentImageInfo"); + break; + + case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO: + dump_string(settings, "VkFramebufferAttachmentsCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO: + dump_string(settings, "VkRenderPassAttachmentBeginInfo"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: + dump_string(settings, "VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures"); + break; + + case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT: + dump_string(settings, "VkAttachmentReferenceStencilLayout"); + break; + + case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT: + dump_string(settings, "VkAttachmentDescriptionStencilLayout"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: + dump_string(settings, "VkPhysicalDeviceVulkan13Features"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: + dump_string(settings, "VkPhysicalDeviceVulkan13Properties"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES: + dump_string(settings, "VkPhysicalDeviceToolProperties"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: + dump_string(settings, "VkPhysicalDevicePrivateDataFeatures"); + break; + + case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO: + dump_string(settings, "VkDevicePrivateDataCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO: + dump_string(settings, "VkPrivateDataSlotCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2: + dump_string(settings, "VkMemoryBarrier2"); + break; + + case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2: + dump_string(settings, "VkBufferMemoryBarrier2"); + break; + + case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2: + dump_string(settings, "VkImageMemoryBarrier2"); + break; + + case VK_STRUCTURE_TYPE_DEPENDENCY_INFO: + dump_string(settings, "VkDependencyInfo"); + break; + + case VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO: + dump_string(settings, "VkSemaphoreSubmitInfo"); + break; + + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO: + dump_string(settings, "VkCommandBufferSubmitInfo"); + break; + + case VK_STRUCTURE_TYPE_SUBMIT_INFO_2: + dump_string(settings, "VkSubmitInfo2"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: + dump_string(settings, "VkPhysicalDeviceSynchronization2Features"); + break; + + case VK_STRUCTURE_TYPE_BUFFER_COPY_2: + dump_string(settings, "VkBufferCopy2"); + break; + + case VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2: + dump_string(settings, "VkCopyBufferInfo2"); + break; + + case VK_STRUCTURE_TYPE_IMAGE_COPY_2: + dump_string(settings, "VkImageCopy2"); + break; + + case VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2: + dump_string(settings, "VkCopyImageInfo2"); + break; + + case VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2: + dump_string(settings, "VkBufferImageCopy2"); + break; + + case VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2: + dump_string(settings, "VkCopyBufferToImageInfo2"); + break; + + case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2: + dump_string(settings, "VkCopyImageToBufferInfo2"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: + dump_string(settings, "VkPhysicalDeviceTextureCompressionASTCHDRFeatures"); + break; + + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3: + dump_string(settings, "VkFormatProperties3"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: + dump_string(settings, "VkPhysicalDeviceMaintenance4Features"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: + dump_string(settings, "VkPhysicalDeviceMaintenance4Properties"); + break; + + case VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS: + dump_string(settings, "VkDeviceBufferMemoryRequirements"); + break; + + case VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS: + dump_string(settings, "VkDeviceImageMemoryRequirements"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: + dump_string(settings, "VkPipelineCreationFeedbackCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: + dump_string(settings, "VkPhysicalDeviceShaderTerminateInvocationFeatures"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: + dump_string(settings, "VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: + dump_string(settings, "VkPhysicalDevicePipelineCreationCacheControlFeatures"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: + dump_string(settings, "VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: + dump_string(settings, "VkPhysicalDeviceImageRobustnessFeatures"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: + dump_string(settings, "VkPhysicalDeviceSubgroupSizeControlFeatures"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: + dump_string(settings, "VkPhysicalDeviceSubgroupSizeControlProperties"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: + dump_string(settings, "VkPipelineShaderStageRequiredSubgroupSizeCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: + dump_string(settings, "VkPhysicalDeviceInlineUniformBlockFeatures"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: + dump_string(settings, "VkPhysicalDeviceInlineUniformBlockProperties"); + break; + + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK: + dump_string(settings, "VkWriteDescriptorSetInlineUniformBlock"); + break; + + case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO: + dump_string(settings, "VkDescriptorPoolInlineUniformBlockCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: + dump_string(settings, "VkPhysicalDeviceShaderIntegerDotProductFeatures"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: + dump_string(settings, "VkPhysicalDeviceShaderIntegerDotProductProperties"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: + dump_string(settings, "VkPhysicalDeviceTexelBufferAlignmentProperties"); + break; + + case VK_STRUCTURE_TYPE_IMAGE_BLIT_2: + dump_string(settings, "VkImageBlit2"); + break; + + case VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2: + dump_string(settings, "VkBlitImageInfo2"); + break; + + case VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2: + dump_string(settings, "VkImageResolve2"); + break; + + case VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2: + dump_string(settings, "VkResolveImageInfo2"); + break; + + case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO: + dump_string(settings, "VkRenderingAttachmentInfo"); + break; + + case VK_STRUCTURE_TYPE_RENDERING_INFO: + dump_string(settings, "VkRenderingInfo"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO: + dump_string(settings, "VkPipelineRenderingCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: + dump_string(settings, "VkPhysicalDeviceDynamicRenderingFeatures"); + break; + + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO: + dump_string(settings, "VkCommandBufferInheritanceRenderingInfo"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES: + dump_string(settings, "VkPhysicalDeviceVulkan14Features"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES: + dump_string(settings, "VkPhysicalDeviceVulkan14Properties"); + break; + + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO: + dump_string(settings, "VkDeviceQueueGlobalPriorityCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES: + dump_string(settings, "VkPhysicalDeviceGlobalPriorityQueryFeatures"); + break; + + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES: + dump_string(settings, "VkQueueFamilyGlobalPriorityProperties"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES: + dump_string(settings, "VkPhysicalDeviceIndexTypeUint8Features"); + break; + + case VK_STRUCTURE_TYPE_MEMORY_MAP_INFO: + dump_string(settings, "VkMemoryMapInfo"); + break; + + case VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO: + dump_string(settings, "VkMemoryUnmapInfo"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES: + dump_string(settings, "VkPhysicalDeviceMaintenance5Features"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES: + dump_string(settings, "VkPhysicalDeviceMaintenance5Properties"); + break; + + case VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2: + dump_string(settings, "VkImageSubresource2"); + break; + + case VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO: + dump_string(settings, "VkDeviceImageSubresourceInfo"); + break; + + case VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2: + dump_string(settings, "VkSubresourceLayout2"); + break; + + case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO: + dump_string(settings, "VkBufferUsageFlags2CreateInfo"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES: + dump_string(settings, "VkPhysicalDeviceMaintenance6Features"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES: + dump_string(settings, "VkPhysicalDeviceMaintenance6Properties"); + break; + + case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS: + dump_string(settings, "VkBindMemoryStatus"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES: + dump_string(settings, "VkPhysicalDeviceHostImageCopyFeatures"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES: + dump_string(settings, "VkPhysicalDeviceHostImageCopyProperties"); + break; + + case VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY: + dump_string(settings, "VkMemoryToImageCopy"); + break; + + case VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY: + dump_string(settings, "VkImageToMemoryCopy"); + break; + + case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO: + dump_string(settings, "VkCopyMemoryToImageInfo"); + break; + + case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO: + dump_string(settings, "VkCopyImageToMemoryInfo"); + break; + + case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO: + dump_string(settings, "VkCopyImageToImageInfo"); + break; + + case VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO: + dump_string(settings, "VkHostImageLayoutTransitionInfo"); + break; + + case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE: + dump_string(settings, "VkSubresourceHostMemcpySize"); + break; + + case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY: + dump_string(settings, "VkHostImageCopyDevicePerformanceQuery"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES: + dump_string(settings, "VkPhysicalDeviceShaderSubgroupRotateFeatures"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES: + dump_string(settings, "VkPhysicalDeviceShaderFloatControls2Features"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES: + dump_string(settings, "VkPhysicalDeviceShaderExpectAssumeFeatures"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO: + dump_string(settings, "VkPipelineCreateFlags2CreateInfo"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES: + dump_string(settings, "VkPhysicalDevicePushDescriptorProperties"); + break; + + case VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO: + dump_string(settings, "VkBindDescriptorSetsInfo"); + break; + + case VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO: + dump_string(settings, "VkPushConstantsInfo"); + break; + + case VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO: + dump_string(settings, "VkPushDescriptorSetInfo"); + break; + + case VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO: + dump_string(settings, "VkPushDescriptorSetWithTemplateInfo"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES: + dump_string(settings, "VkPhysicalDevicePipelineProtectedAccessFeatures"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES: + dump_string(settings, "VkPhysicalDevicePipelineRobustnessFeatures"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES: + dump_string(settings, "VkPhysicalDevicePipelineRobustnessProperties"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO: + dump_string(settings, "VkPipelineRobustnessCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES: + dump_string(settings, "VkPhysicalDeviceLineRasterizationFeatures"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES: + dump_string(settings, "VkPhysicalDeviceLineRasterizationProperties"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO: + dump_string(settings, "VkPipelineRasterizationLineStateCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES: + dump_string(settings, "VkPhysicalDeviceVertexAttributeDivisorProperties"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO: + dump_string(settings, "VkPipelineVertexInputDivisorStateCreateInfo"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES: + dump_string(settings, "VkPhysicalDeviceVertexAttributeDivisorFeatures"); + break; + + case VK_STRUCTURE_TYPE_RENDERING_AREA_INFO: + dump_string(settings, "VkRenderingAreaInfo"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES: + dump_string(settings, "VkPhysicalDeviceDynamicRenderingLocalReadFeatures"); + break; + + case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO: + dump_string(settings, "VkRenderingAttachmentLocationInfo"); + break; + + case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO: + dump_string(settings, "VkRenderingInputAttachmentIndexInfo"); + break; + + case VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR: + dump_string(settings, "VkSwapchainCreateInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_PRESENT_INFO_KHR: + dump_string(settings, "VkPresentInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: + dump_string(settings, "VkImageSwapchainCreateInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR: + dump_string(settings, "VkBindImageMemorySwapchainInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR: + dump_string(settings, "VkAcquireNextImageInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR: + dump_string(settings, "VkDeviceGroupPresentCapabilitiesKHR"); + break; + + case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR: + dump_string(settings, "VkDeviceGroupPresentInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR: + dump_string(settings, "VkDeviceGroupSwapchainCreateInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR: + dump_string(settings, "VkDisplayModeCreateInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR: + dump_string(settings, "VkDisplaySurfaceCreateInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR: + dump_string(settings, "VkDisplayPresentInfoKHR"); + break; +#if defined(VK_USE_PLATFORM_XLIB_KHR) + + case VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR: + dump_string(settings, "VkXlibSurfaceCreateInfoKHR"); + break; +#endif // VK_USE_PLATFORM_XLIB_KHR +#if defined(VK_USE_PLATFORM_XCB_KHR) + + case VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR: + dump_string(settings, "VkXcbSurfaceCreateInfoKHR"); + break; +#endif // VK_USE_PLATFORM_XCB_KHR +#if defined(VK_USE_PLATFORM_WAYLAND_KHR) + + case VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR: + dump_string(settings, "VkWaylandSurfaceCreateInfoKHR"); + break; +#endif // VK_USE_PLATFORM_WAYLAND_KHR +#if defined(VK_USE_PLATFORM_ANDROID_KHR) + + case VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR: + dump_string(settings, "VkAndroidSurfaceCreateInfoKHR"); + break; +#endif // VK_USE_PLATFORM_ANDROID_KHR +#if defined(VK_USE_PLATFORM_WIN32_KHR) + + case VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR: + dump_string(settings, "VkWin32SurfaceCreateInfoKHR"); + break; +#endif // VK_USE_PLATFORM_WIN32_KHR + + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR: + dump_string(settings, "VkQueueFamilyQueryResultStatusPropertiesKHR"); + break; + + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR: + dump_string(settings, "VkQueueFamilyVideoPropertiesKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR: + dump_string(settings, "VkVideoProfileInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR: + dump_string(settings, "VkVideoProfileListInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR: + dump_string(settings, "VkVideoCapabilitiesKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR: + dump_string(settings, "VkPhysicalDeviceVideoFormatInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR: + dump_string(settings, "VkVideoFormatPropertiesKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR: + dump_string(settings, "VkVideoPictureResourceInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR: + dump_string(settings, "VkVideoReferenceSlotInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR: + dump_string(settings, "VkVideoSessionMemoryRequirementsKHR"); + break; + + case VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR: + dump_string(settings, "VkBindVideoSessionMemoryInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR: + dump_string(settings, "VkVideoSessionCreateInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR: + dump_string(settings, "VkVideoSessionParametersCreateInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR: + dump_string(settings, "VkVideoSessionParametersUpdateInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR: + dump_string(settings, "VkVideoBeginCodingInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR: + dump_string(settings, "VkVideoEndCodingInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR: + dump_string(settings, "VkVideoCodingControlInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR: + dump_string(settings, "VkVideoDecodeCapabilitiesKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR: + dump_string(settings, "VkVideoDecodeUsageInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR: + dump_string(settings, "VkVideoDecodeInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR: + dump_string(settings, "VkVideoEncodeH264CapabilitiesKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR: + dump_string(settings, "VkVideoEncodeH264QualityLevelPropertiesKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR: + dump_string(settings, "VkVideoEncodeH264SessionCreateInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: + dump_string(settings, "VkVideoEncodeH264SessionParametersAddInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: + dump_string(settings, "VkVideoEncodeH264SessionParametersCreateInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR: + dump_string(settings, "VkVideoEncodeH264SessionParametersGetInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: + dump_string(settings, "VkVideoEncodeH264SessionParametersFeedbackInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR: + dump_string(settings, "VkVideoEncodeH264NaluSliceInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR: + dump_string(settings, "VkVideoEncodeH264PictureInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR: + dump_string(settings, "VkVideoEncodeH264DpbSlotInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR: + dump_string(settings, "VkVideoEncodeH264ProfileInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR: + dump_string(settings, "VkVideoEncodeH264RateControlInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR: + dump_string(settings, "VkVideoEncodeH264RateControlLayerInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR: + dump_string(settings, "VkVideoEncodeH264GopRemainingFrameInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR: + dump_string(settings, "VkVideoEncodeH265CapabilitiesKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR: + dump_string(settings, "VkVideoEncodeH265SessionCreateInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR: + dump_string(settings, "VkVideoEncodeH265QualityLevelPropertiesKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: + dump_string(settings, "VkVideoEncodeH265SessionParametersAddInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: + dump_string(settings, "VkVideoEncodeH265SessionParametersCreateInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR: + dump_string(settings, "VkVideoEncodeH265SessionParametersGetInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: + dump_string(settings, "VkVideoEncodeH265SessionParametersFeedbackInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR: + dump_string(settings, "VkVideoEncodeH265NaluSliceSegmentInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR: + dump_string(settings, "VkVideoEncodeH265PictureInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR: + dump_string(settings, "VkVideoEncodeH265DpbSlotInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR: + dump_string(settings, "VkVideoEncodeH265ProfileInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR: + dump_string(settings, "VkVideoEncodeH265RateControlInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR: + dump_string(settings, "VkVideoEncodeH265RateControlLayerInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR: + dump_string(settings, "VkVideoEncodeH265GopRemainingFrameInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR: + dump_string(settings, "VkVideoDecodeH264ProfileInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR: + dump_string(settings, "VkVideoDecodeH264CapabilitiesKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: + dump_string(settings, "VkVideoDecodeH264SessionParametersAddInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: + dump_string(settings, "VkVideoDecodeH264SessionParametersCreateInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR: + dump_string(settings, "VkVideoDecodeH264PictureInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR: + dump_string(settings, "VkVideoDecodeH264DpbSlotInfoKHR"); + break; +#if defined(VK_USE_PLATFORM_WIN32_KHR) + + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: + dump_string(settings, "VkImportMemoryWin32HandleInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR: + dump_string(settings, "VkExportMemoryWin32HandleInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR: + dump_string(settings, "VkMemoryWin32HandlePropertiesKHR"); + break; + + case VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR: + dump_string(settings, "VkMemoryGetWin32HandleInfoKHR"); + break; +#endif // VK_USE_PLATFORM_WIN32_KHR + + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR: + dump_string(settings, "VkImportMemoryFdInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR: + dump_string(settings, "VkMemoryFdPropertiesKHR"); + break; + + case VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR: + dump_string(settings, "VkMemoryGetFdInfoKHR"); + break; +#if defined(VK_USE_PLATFORM_WIN32_KHR) + + case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR: + dump_string(settings, "VkWin32KeyedMutexAcquireReleaseInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: + dump_string(settings, "VkImportSemaphoreWin32HandleInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: + dump_string(settings, "VkExportSemaphoreWin32HandleInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR: + dump_string(settings, "VkD3D12FenceSubmitInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR: + dump_string(settings, "VkSemaphoreGetWin32HandleInfoKHR"); + break; +#endif // VK_USE_PLATFORM_WIN32_KHR + + case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR: + dump_string(settings, "VkImportSemaphoreFdInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR: + dump_string(settings, "VkSemaphoreGetFdInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR: + dump_string(settings, "VkPresentRegionsKHR"); + break; + + case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: + dump_string(settings, "VkSharedPresentSurfaceCapabilitiesKHR"); + break; +#if defined(VK_USE_PLATFORM_WIN32_KHR) + + case VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR: + dump_string(settings, "VkImportFenceWin32HandleInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR: + dump_string(settings, "VkExportFenceWin32HandleInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR: + dump_string(settings, "VkFenceGetWin32HandleInfoKHR"); + break; +#endif // VK_USE_PLATFORM_WIN32_KHR + + case VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR: + dump_string(settings, "VkImportFenceFdInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR: + dump_string(settings, "VkFenceGetFdInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: + dump_string(settings, "VkPhysicalDevicePerformanceQueryFeaturesKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR: + dump_string(settings, "VkPhysicalDevicePerformanceQueryPropertiesKHR"); + break; + + case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR: + dump_string(settings, "VkPerformanceCounterKHR"); + break; + + case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR: + dump_string(settings, "VkPerformanceCounterDescriptionKHR"); + break; + + case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR: + dump_string(settings, "VkQueryPoolPerformanceCreateInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR: + dump_string(settings, "VkAcquireProfilingLockInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR: + dump_string(settings, "VkPerformanceQuerySubmitInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR: + dump_string(settings, "VkPhysicalDeviceSurfaceInfo2KHR"); + break; + + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR: + dump_string(settings, "VkSurfaceCapabilities2KHR"); + break; + + case VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR: + dump_string(settings, "VkSurfaceFormat2KHR"); + break; + + case VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR: + dump_string(settings, "VkDisplayProperties2KHR"); + break; + + case VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR: + dump_string(settings, "VkDisplayPlaneProperties2KHR"); + break; + + case VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR: + dump_string(settings, "VkDisplayModeProperties2KHR"); + break; + + case VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR: + dump_string(settings, "VkDisplayPlaneInfo2KHR"); + break; + + case VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR: + dump_string(settings, "VkDisplayPlaneCapabilities2KHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR: + dump_string(settings, "VkPhysicalDeviceShaderBfloat16FeaturesKHR"); + break; +#if defined(VK_ENABLE_BETA_EXTENSIONS) + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: + dump_string(settings, "VkPhysicalDevicePortabilitySubsetFeaturesKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR: + dump_string(settings, "VkPhysicalDevicePortabilitySubsetPropertiesKHR"); + break; +#endif // VK_ENABLE_BETA_EXTENSIONS + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: + dump_string(settings, "VkPhysicalDeviceShaderClockFeaturesKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR: + dump_string(settings, "VkVideoDecodeH265ProfileInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR: + dump_string(settings, "VkVideoDecodeH265CapabilitiesKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: + dump_string(settings, "VkVideoDecodeH265SessionParametersAddInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: + dump_string(settings, "VkVideoDecodeH265SessionParametersCreateInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR: + dump_string(settings, "VkVideoDecodeH265PictureInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR: + dump_string(settings, "VkVideoDecodeH265DpbSlotInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: + dump_string(settings, "VkFragmentShadingRateAttachmentInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR: + dump_string(settings, "VkPipelineFragmentShadingRateStateCreateInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: + dump_string(settings, "VkPhysicalDeviceFragmentShadingRateFeaturesKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR: + dump_string(settings, "VkPhysicalDeviceFragmentShadingRatePropertiesKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR: + dump_string(settings, "VkPhysicalDeviceFragmentShadingRateKHR"); + break; + + case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: + dump_string(settings, "VkRenderingFragmentShadingRateAttachmentInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR: + dump_string(settings, "VkPhysicalDeviceShaderQuadControlFeaturesKHR"); + break; + + case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR: + dump_string(settings, "VkSurfaceProtectedCapabilitiesKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: + dump_string(settings, "VkPhysicalDevicePresentWaitFeaturesKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: + dump_string(settings, "VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR: + dump_string(settings, "VkPipelineInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR: + dump_string(settings, "VkPipelineExecutablePropertiesKHR"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR: + dump_string(settings, "VkPipelineExecutableInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR: + dump_string(settings, "VkPipelineExecutableStatisticKHR"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR: + dump_string(settings, "VkPipelineExecutableInternalRepresentationKHR"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: + dump_string(settings, "VkPipelineLibraryCreateInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_PRESENT_ID_KHR: + dump_string(settings, "VkPresentIdKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: + dump_string(settings, "VkPhysicalDevicePresentIdFeaturesKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR: + dump_string(settings, "VkVideoEncodeInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR: + dump_string(settings, "VkVideoEncodeCapabilitiesKHR"); + break; + + case VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR: + dump_string(settings, "VkQueryPoolVideoEncodeFeedbackCreateInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR: + dump_string(settings, "VkVideoEncodeUsageInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR: + dump_string(settings, "VkVideoEncodeRateControlLayerInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: + dump_string(settings, "VkVideoEncodeRateControlInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR: + dump_string(settings, "VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR: + dump_string(settings, "VkVideoEncodeQualityLevelPropertiesKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR: + dump_string(settings, "VkVideoEncodeQualityLevelInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR: + dump_string(settings, "VkVideoEncodeSessionParametersGetInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: + dump_string(settings, "VkVideoEncodeSessionParametersFeedbackInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: + dump_string(settings, "VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR: + dump_string(settings, "VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: + dump_string(settings, "VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: + dump_string(settings, "VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: + dump_string(settings, "VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR: + dump_string(settings, "VkPhysicalDeviceShaderUntypedPointersFeaturesKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: + dump_string(settings, "VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR"); + break; + + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR: + dump_string(settings, "VkSurfaceCapabilitiesPresentId2KHR"); + break; + + case VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR: + dump_string(settings, "VkPresentId2KHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR: + dump_string(settings, "VkPhysicalDevicePresentId2FeaturesKHR"); + break; + + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR: + dump_string(settings, "VkSurfaceCapabilitiesPresentWait2KHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR: + dump_string(settings, "VkPhysicalDevicePresentWait2FeaturesKHR"); + break; + + case VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR: + dump_string(settings, "VkPresentWait2InfoKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: + dump_string(settings, "VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR: + dump_string(settings, "VkPhysicalDevicePipelineBinaryFeaturesKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR: + dump_string(settings, "VkPhysicalDevicePipelineBinaryPropertiesKHR"); + break; + + case VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR: + dump_string(settings, "VkDevicePipelineBinaryInternalCacheControlKHR"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR: + dump_string(settings, "VkPipelineBinaryKeyKHR"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR: + dump_string(settings, "VkPipelineCreateInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR: + dump_string(settings, "VkPipelineBinaryCreateInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR: + dump_string(settings, "VkPipelineBinaryInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR: + dump_string(settings, "VkReleaseCapturedPipelineDataInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR: + dump_string(settings, "VkPipelineBinaryDataInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR: + dump_string(settings, "VkPipelineBinaryHandlesInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR: + dump_string(settings, "VkSurfacePresentModeKHR"); + break; + + case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR: + dump_string(settings, "VkSurfacePresentScalingCapabilitiesKHR"); + break; + + case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR: + dump_string(settings, "VkSurfacePresentModeCompatibilityKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR: + dump_string(settings, "VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR"); + break; + + case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR: + dump_string(settings, "VkSwapchainPresentFenceInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR: + dump_string(settings, "VkSwapchainPresentModesCreateInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR: + dump_string(settings, "VkSwapchainPresentModeInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR: + dump_string(settings, "VkSwapchainPresentScalingCreateInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR: + dump_string(settings, "VkReleaseSwapchainImagesInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR: + dump_string(settings, "VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR"); + break; + + case VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR: + dump_string(settings, "VkCooperativeMatrixPropertiesKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR: + dump_string(settings, "VkPhysicalDeviceCooperativeMatrixFeaturesKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR: + dump_string(settings, "VkPhysicalDeviceCooperativeMatrixPropertiesKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR: + dump_string(settings, "VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR: + dump_string(settings, "VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR: + dump_string(settings, "VkVideoDecodeAV1ProfileInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR: + dump_string(settings, "VkVideoDecodeAV1CapabilitiesKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR: + dump_string(settings, "VkVideoDecodeAV1SessionParametersCreateInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR: + dump_string(settings, "VkVideoDecodeAV1PictureInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR: + dump_string(settings, "VkVideoDecodeAV1DpbSlotInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR: + dump_string(settings, "VkPhysicalDeviceVideoEncodeAV1FeaturesKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR: + dump_string(settings, "VkVideoEncodeAV1CapabilitiesKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR: + dump_string(settings, "VkVideoEncodeAV1QualityLevelPropertiesKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR: + dump_string(settings, "VkVideoEncodeAV1SessionCreateInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR: + dump_string(settings, "VkVideoEncodeAV1SessionParametersCreateInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR: + dump_string(settings, "VkVideoEncodeAV1PictureInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR: + dump_string(settings, "VkVideoEncodeAV1DpbSlotInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR: + dump_string(settings, "VkVideoEncodeAV1ProfileInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR: + dump_string(settings, "VkVideoEncodeAV1GopRemainingFrameInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR: + dump_string(settings, "VkVideoEncodeAV1RateControlInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR: + dump_string(settings, "VkVideoEncodeAV1RateControlLayerInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR: + dump_string(settings, "VkPhysicalDeviceVideoDecodeVP9FeaturesKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR: + dump_string(settings, "VkVideoDecodeVP9ProfileInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR: + dump_string(settings, "VkVideoDecodeVP9CapabilitiesKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR: + dump_string(settings, "VkVideoDecodeVP9PictureInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: + dump_string(settings, "VkPhysicalDeviceVideoMaintenance1FeaturesKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR: + dump_string(settings, "VkVideoInlineQueryInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR: + dump_string(settings, "VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR"); + break; + + case VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT: + dump_string(settings, "VkAttachmentFeedbackLoopInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR: + dump_string(settings, "VkCalibratedTimestampInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT: + dump_string(settings, "VkSetDescriptorBufferOffsetsInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT: + dump_string(settings, "VkBindDescriptorBufferEmbeddedSamplersInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_COPY_MEMORY_INDIRECT_INFO_KHR: + dump_string(settings, "VkCopyMemoryIndirectInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INDIRECT_INFO_KHR: + dump_string(settings, "VkCopyMemoryToImageIndirectInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR: + dump_string(settings, "VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR: + dump_string(settings, "VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR: + dump_string(settings, "VkVideoEncodeIntraRefreshCapabilitiesKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR: + dump_string(settings, "VkVideoEncodeSessionIntraRefreshCreateInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR: + dump_string(settings, "VkVideoEncodeIntraRefreshInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR: + dump_string(settings, "VkVideoReferenceIntraRefreshInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR: + dump_string(settings, "VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR: + dump_string(settings, "VkVideoEncodeQuantizationMapCapabilitiesKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR: + dump_string(settings, "VkVideoFormatQuantizationMapPropertiesKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR: + dump_string(settings, "VkVideoEncodeQuantizationMapInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR: + dump_string(settings, "VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR: + dump_string(settings, "VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR: + dump_string(settings, "VkVideoEncodeH264QuantizationMapCapabilitiesKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR: + dump_string(settings, "VkVideoEncodeH265QuantizationMapCapabilitiesKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR: + dump_string(settings, "VkVideoFormatH265QuantizationMapPropertiesKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR: + dump_string(settings, "VkVideoEncodeAV1QuantizationMapCapabilitiesKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR: + dump_string(settings, "VkVideoFormatAV1QuantizationMapPropertiesKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR: + dump_string(settings, "VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR: + dump_string(settings, "VkPhysicalDeviceMaintenance7FeaturesKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR: + dump_string(settings, "VkPhysicalDeviceMaintenance7PropertiesKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR: + dump_string(settings, "VkPhysicalDeviceLayeredApiPropertiesKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR: + dump_string(settings, "VkPhysicalDeviceLayeredApiPropertiesListKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR: + dump_string(settings, "VkPhysicalDeviceLayeredApiVulkanPropertiesKHR"); + break; + + case VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR: + dump_string(settings, "VkMemoryBarrierAccessFlags3KHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR: + dump_string(settings, "VkPhysicalDeviceMaintenance8FeaturesKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR: + dump_string(settings, "VkPhysicalDeviceShaderFmaFeaturesKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR: + dump_string(settings, "VkPhysicalDeviceMaintenance9FeaturesKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR: + dump_string(settings, "VkPhysicalDeviceMaintenance9PropertiesKHR"); + break; + + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR: + dump_string(settings, "VkQueueFamilyOwnershipTransferPropertiesKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR: + dump_string(settings, "VkPhysicalDeviceVideoMaintenance2FeaturesKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR: + dump_string(settings, "VkVideoDecodeH264InlineSessionParametersInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR: + dump_string(settings, "VkVideoDecodeH265InlineSessionParametersInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR: + dump_string(settings, "VkVideoDecodeAV1InlineSessionParametersInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR: + dump_string(settings, "VkPhysicalDeviceDepthClampZeroOneFeaturesKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR: + dump_string(settings, "VkPhysicalDeviceRobustness2FeaturesKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR: + dump_string(settings, "VkPhysicalDeviceRobustness2PropertiesKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR: + dump_string(settings, "VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR: + dump_string(settings, "VkPhysicalDeviceMaintenance10FeaturesKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR: + dump_string(settings, "VkPhysicalDeviceMaintenance10PropertiesKHR"); + break; + + case VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR: + dump_string(settings, "VkRenderingEndInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_FLAGS_INFO_KHR: + dump_string(settings, "VkRenderingAttachmentFlagsInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_RESOLVE_IMAGE_MODE_INFO_KHR: + dump_string(settings, "VkResolveImageModeInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: + dump_string(settings, "VkDebugReportCallbackCreateInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: + dump_string(settings, "VkPipelineRasterizationStateRasterizationOrderAMD"); + break; + + case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT: + dump_string(settings, "VkDebugMarkerObjectNameInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT: + dump_string(settings, "VkDebugMarkerObjectTagInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT: + dump_string(settings, "VkDebugMarkerMarkerInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: + dump_string(settings, "VkDedicatedAllocationImageCreateInfoNV"); + break; + + case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: + dump_string(settings, "VkDedicatedAllocationBufferCreateInfoNV"); + break; + + case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: + dump_string(settings, "VkDedicatedAllocationMemoryAllocateInfoNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceTransformFeedbackFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: + dump_string(settings, "VkPhysicalDeviceTransformFeedbackPropertiesEXT"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: + dump_string(settings, "VkPipelineRasterizationStateStreamCreateInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX: + dump_string(settings, "VkCuModuleCreateInfoNVX"); + break; + + case VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX: + dump_string(settings, "VkCuModuleTexturingModeCreateInfoNVX"); + break; + + case VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX: + dump_string(settings, "VkCuFunctionCreateInfoNVX"); + break; + + case VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX: + dump_string(settings, "VkCuLaunchInfoNVX"); + break; + + case VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX: + dump_string(settings, "VkImageViewHandleInfoNVX"); + break; + + case VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX: + dump_string(settings, "VkImageViewAddressPropertiesNVX"); + break; + + case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: + dump_string(settings, "VkTextureLODGatherFormatPropertiesAMD"); + break; +#if defined(VK_USE_PLATFORM_GGP) + + case VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP: + dump_string(settings, "VkStreamDescriptorSurfaceCreateInfoGGP"); + break; +#endif // VK_USE_PLATFORM_GGP + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: + dump_string(settings, "VkPhysicalDeviceCornerSampledImageFeaturesNV"); + break; + + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV: + dump_string(settings, "VkExternalMemoryImageCreateInfoNV"); + break; + + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV: + dump_string(settings, "VkExportMemoryAllocateInfoNV"); + break; +#if defined(VK_USE_PLATFORM_WIN32_KHR) + + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV: + dump_string(settings, "VkImportMemoryWin32HandleInfoNV"); + break; + + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV: + dump_string(settings, "VkExportMemoryWin32HandleInfoNV"); + break; + + case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV: + dump_string(settings, "VkWin32KeyedMutexAcquireReleaseInfoNV"); + break; +#endif // VK_USE_PLATFORM_WIN32_KHR + + case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT: + dump_string(settings, "VkValidationFlagsEXT"); + break; +#if defined(VK_USE_PLATFORM_VI_NN) + + case VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN: + dump_string(settings, "VkViSurfaceCreateInfoNN"); + break; +#endif // VK_USE_PLATFORM_VI_NN + + case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: + dump_string(settings, "VkImageViewASTCDecodeModeEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceASTCDecodeFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT: + dump_string(settings, "VkConditionalRenderingBeginInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceConditionalRenderingFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT: + dump_string(settings, "VkCommandBufferInheritanceConditionalRenderingInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: + dump_string(settings, "VkPipelineViewportWScalingStateCreateInfoNV"); + break; + + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT: + dump_string(settings, "VkSurfaceCapabilities2EXT"); + break; + + case VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT: + dump_string(settings, "VkDisplayPowerInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT: + dump_string(settings, "VkDeviceEventInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT: + dump_string(settings, "VkDisplayEventInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT: + dump_string(settings, "VkSwapchainCounterCreateInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE: + dump_string(settings, "VkPresentTimesInfoGOOGLE"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX: + dump_string(settings, "VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX"); + break; + + case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: + dump_string(settings, "VkMultiviewPerViewAttributesInfoNVX"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: + dump_string(settings, "VkPipelineViewportSwizzleStateCreateInfoNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: + dump_string(settings, "VkPhysicalDeviceDiscardRectanglePropertiesEXT"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: + dump_string(settings, "VkPipelineDiscardRectangleStateCreateInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: + dump_string(settings, "VkPhysicalDeviceConservativeRasterizationPropertiesEXT"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: + dump_string(settings, "VkPipelineRasterizationConservativeStateCreateInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceDepthClipEnableFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: + dump_string(settings, "VkPipelineRasterizationDepthClipStateCreateInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_HDR_METADATA_EXT: + dump_string(settings, "VkHdrMetadataEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: + dump_string(settings, "VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG"); + break; +#if defined(VK_USE_PLATFORM_IOS_MVK) + + case VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK: + dump_string(settings, "VkIOSSurfaceCreateInfoMVK"); + break; +#endif // VK_USE_PLATFORM_IOS_MVK +#if defined(VK_USE_PLATFORM_MACOS_MVK) + + case VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK: + dump_string(settings, "VkMacOSSurfaceCreateInfoMVK"); + break; +#endif // VK_USE_PLATFORM_MACOS_MVK + + case VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT: + dump_string(settings, "VkDebugUtilsLabelEXT"); + break; + + case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: + dump_string(settings, "VkDebugUtilsObjectNameInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT: + dump_string(settings, "VkDebugUtilsMessengerCallbackDataEXT"); + break; + + case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: + dump_string(settings, "VkDebugUtilsMessengerCreateInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT: + dump_string(settings, "VkDebugUtilsObjectTagInfoEXT"); + break; +#if defined(VK_USE_PLATFORM_ANDROID_KHR) + + case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID: + dump_string(settings, "VkAndroidHardwareBufferUsageANDROID"); + break; + + case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID: + dump_string(settings, "VkAndroidHardwareBufferPropertiesANDROID"); + break; + + case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID: + dump_string(settings, "VkAndroidHardwareBufferFormatPropertiesANDROID"); + break; + + case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: + dump_string(settings, "VkImportAndroidHardwareBufferInfoANDROID"); + break; + + case VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: + dump_string(settings, "VkMemoryGetAndroidHardwareBufferInfoANDROID"); + break; + + case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID: + dump_string(settings, "VkExternalFormatANDROID"); + break; + + case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID: + dump_string(settings, "VkAndroidHardwareBufferFormatProperties2ANDROID"); + break; +#endif // VK_USE_PLATFORM_ANDROID_KHR +#if defined(VK_ENABLE_BETA_EXTENSIONS) + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX: + dump_string(settings, "VkPhysicalDeviceShaderEnqueueFeaturesAMDX"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX: + dump_string(settings, "VkPhysicalDeviceShaderEnqueuePropertiesAMDX"); + break; + + case VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX: + dump_string(settings, "VkExecutionGraphPipelineScratchSizeAMDX"); + break; + + case VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX: + dump_string(settings, "VkExecutionGraphPipelineCreateInfoAMDX"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX: + dump_string(settings, "VkPipelineShaderStageNodeCreateInfoAMDX"); + break; +#endif // VK_ENABLE_BETA_EXTENSIONS + + case VK_STRUCTURE_TYPE_TEXEL_BUFFER_DESCRIPTOR_INFO_EXT: + dump_string(settings, "VkTexelBufferDescriptorInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_IMAGE_DESCRIPTOR_INFO_EXT: + dump_string(settings, "VkImageDescriptorInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM: + dump_string(settings, "VkTensorViewCreateInfoARM"); + break; + + case VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT: + dump_string(settings, "VkResourceDescriptorInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_BIND_HEAP_INFO_EXT: + dump_string(settings, "VkBindHeapInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_PUSH_DATA_INFO_EXT: + dump_string(settings, "VkPushDataInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_AND_BINDING_MAPPING_EXT: + dump_string(settings, "VkDescriptorSetAndBindingMappingEXT"); + break; + + case VK_STRUCTURE_TYPE_SHADER_DESCRIPTOR_SET_AND_BINDING_MAPPING_INFO_EXT: + dump_string(settings, "VkShaderDescriptorSetAndBindingMappingInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DATA_CREATE_INFO_EXT: + dump_string(settings, "VkOpaqueCaptureDataCreateInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceDescriptorHeapFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES_EXT: + dump_string(settings, "VkPhysicalDeviceDescriptorHeapPropertiesEXT"); + break; + + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_DESCRIPTOR_HEAP_INFO_EXT: + dump_string(settings, "VkCommandBufferInheritanceDescriptorHeapInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_INDEX_CREATE_INFO_EXT: + dump_string(settings, "VkSamplerCustomBorderColorIndexCreateInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: + dump_string(settings, "VkSamplerCustomBorderColorCreateInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_PUSH_DATA_TOKEN_NV: + dump_string(settings, "VkIndirectCommandsLayoutPushDataTokenNV"); + break; + + case VK_STRUCTURE_TYPE_SUBSAMPLED_IMAGE_FORMAT_PROPERTIES_EXT: + dump_string(settings, "VkSubsampledImageFormatPropertiesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_TENSOR_PROPERTIES_ARM: + dump_string(settings, "VkPhysicalDeviceDescriptorHeapTensorPropertiesARM"); + break; + + case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: + dump_string(settings, "VkAttachmentSampleCountInfoAMD"); + break; + + case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: + dump_string(settings, "VkSampleLocationsInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT: + dump_string(settings, "VkRenderPassSampleLocationsBeginInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: + dump_string(settings, "VkPipelineSampleLocationsStateCreateInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: + dump_string(settings, "VkPhysicalDeviceSampleLocationsPropertiesEXT"); + break; + + case VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT: + dump_string(settings, "VkMultisamplePropertiesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: + dump_string(settings, "VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: + dump_string(settings, "VkPipelineColorBlendAdvancedStateCreateInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: + dump_string(settings, "VkPipelineCoverageToColorStateCreateInfoNV"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: + dump_string(settings, "VkPipelineCoverageModulationStateCreateInfoNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV: + dump_string(settings, "VkPhysicalDeviceShaderSMBuiltinsPropertiesNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: + dump_string(settings, "VkPhysicalDeviceShaderSMBuiltinsFeaturesNV"); + break; + + case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: + dump_string(settings, "VkDrmFormatModifierPropertiesListEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT: + dump_string(settings, "VkPhysicalDeviceImageDrmFormatModifierInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: + dump_string(settings, "VkImageDrmFormatModifierListCreateInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: + dump_string(settings, "VkImageDrmFormatModifierExplicitCreateInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT: + dump_string(settings, "VkImageDrmFormatModifierPropertiesEXT"); + break; + + case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT: + dump_string(settings, "VkDrmFormatModifierPropertiesList2EXT"); + break; + + case VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT: + dump_string(settings, "VkValidationCacheCreateInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: + dump_string(settings, "VkShaderModuleValidationCacheCreateInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV: + dump_string(settings, "VkPipelineViewportShadingRateImageStateCreateInfoNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: + dump_string(settings, "VkPhysicalDeviceShadingRateImageFeaturesNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV: + dump_string(settings, "VkPhysicalDeviceShadingRateImagePropertiesNV"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV: + dump_string(settings, "VkPipelineViewportCoarseSampleOrderStateCreateInfoNV"); + break; + + case VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV: + dump_string(settings, "VkRayTracingShaderGroupCreateInfoNV"); + break; + + case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV: + dump_string(settings, "VkRayTracingPipelineCreateInfoNV"); + break; + + case VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV: + dump_string(settings, "VkGeometryTrianglesNV"); + break; + + case VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV: + dump_string(settings, "VkGeometryAABBNV"); + break; + + case VK_STRUCTURE_TYPE_GEOMETRY_NV: + dump_string(settings, "VkGeometryNV"); + break; + + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV: + dump_string(settings, "VkAccelerationStructureInfoNV"); + break; + + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV: + dump_string(settings, "VkAccelerationStructureCreateInfoNV"); + break; + + case VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV: + dump_string(settings, "VkBindAccelerationStructureMemoryInfoNV"); + break; + + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV: + dump_string(settings, "VkWriteDescriptorSetAccelerationStructureNV"); + break; + + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV: + dump_string(settings, "VkAccelerationStructureMemoryRequirementsInfoNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV: + dump_string(settings, "VkPhysicalDeviceRayTracingPropertiesNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: + dump_string(settings, "VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV: + dump_string(settings, "VkPipelineRepresentativeFragmentTestStateCreateInfoNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT: + dump_string(settings, "VkPhysicalDeviceImageViewImageFormatInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT: + dump_string(settings, "VkFilterCubicImageViewImageFormatPropertiesEXT"); + break; + + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: + dump_string(settings, "VkImportMemoryHostPointerInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT: + dump_string(settings, "VkMemoryHostPointerPropertiesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: + dump_string(settings, "VkPhysicalDeviceExternalMemoryHostPropertiesEXT"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: + dump_string(settings, "VkPipelineCompilerControlCreateInfoAMD"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: + dump_string(settings, "VkPhysicalDeviceShaderCorePropertiesAMD"); + break; + + case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: + dump_string(settings, "VkDeviceMemoryOverallocationCreateInfoAMD"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: + dump_string(settings, "VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT"); + break; +#if defined(VK_USE_PLATFORM_GGP) + + case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP: + dump_string(settings, "VkPresentFrameTokenGGP"); + break; +#endif // VK_USE_PLATFORM_GGP + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: + dump_string(settings, "VkPhysicalDeviceMeshShaderFeaturesNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV: + dump_string(settings, "VkPhysicalDeviceMeshShaderPropertiesNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: + dump_string(settings, "VkPhysicalDeviceShaderImageFootprintFeaturesNV"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV: + dump_string(settings, "VkPipelineViewportExclusiveScissorStateCreateInfoNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: + dump_string(settings, "VkPhysicalDeviceExclusiveScissorFeaturesNV"); + break; + + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV: + dump_string(settings, "VkQueueFamilyCheckpointPropertiesNV"); + break; + + case VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV: + dump_string(settings, "VkCheckpointDataNV"); + break; + + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: + dump_string(settings, "VkQueueFamilyCheckpointProperties2NV"); + break; + + case VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV: + dump_string(settings, "VkCheckpointData2NV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT: + dump_string(settings, "VkPhysicalDevicePresentTimingFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT: + dump_string(settings, "VkPresentTimingSurfaceCapabilitiesEXT"); + break; + + case VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT: + dump_string(settings, "VkSwapchainCalibratedTimestampInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_SWAPCHAIN_TIMING_PROPERTIES_EXT: + dump_string(settings, "VkSwapchainTimingPropertiesEXT"); + break; + + case VK_STRUCTURE_TYPE_SWAPCHAIN_TIME_DOMAIN_PROPERTIES_EXT: + dump_string(settings, "VkSwapchainTimeDomainPropertiesEXT"); + break; + + case VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_INFO_EXT: + dump_string(settings, "VkPastPresentationTimingInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_EXT: + dump_string(settings, "VkPastPresentationTimingEXT"); + break; + + case VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_PROPERTIES_EXT: + dump_string(settings, "VkPastPresentationTimingPropertiesEXT"); + break; + + case VK_STRUCTURE_TYPE_PRESENT_TIMING_INFO_EXT: + dump_string(settings, "VkPresentTimingInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT: + dump_string(settings, "VkPresentTimingsInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: + dump_string(settings, "VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL"); + break; + + case VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL: + dump_string(settings, "VkInitializePerformanceApiInfoINTEL"); + break; + + case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL: + dump_string(settings, "VkQueryPoolPerformanceQueryCreateInfoINTEL"); + break; + + case VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL: + dump_string(settings, "VkPerformanceMarkerInfoINTEL"); + break; + + case VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL: + dump_string(settings, "VkPerformanceStreamMarkerInfoINTEL"); + break; + + case VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL: + dump_string(settings, "VkPerformanceOverrideInfoINTEL"); + break; + + case VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL: + dump_string(settings, "VkPerformanceConfigurationAcquireInfoINTEL"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: + dump_string(settings, "VkPhysicalDevicePCIBusInfoPropertiesEXT"); + break; + + case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD: + dump_string(settings, "VkDisplayNativeHdrSurfaceCapabilitiesAMD"); + break; + + case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD: + dump_string(settings, "VkSwapchainDisplayNativeHdrCreateInfoAMD"); + break; +#if defined(VK_USE_PLATFORM_FUCHSIA) + + case VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA: + dump_string(settings, "VkImagePipeSurfaceCreateInfoFUCHSIA"); + break; +#endif // VK_USE_PLATFORM_FUCHSIA +#if defined(VK_USE_PLATFORM_METAL_EXT) + + case VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT: + dump_string(settings, "VkMetalSurfaceCreateInfoEXT"); + break; +#endif // VK_USE_PLATFORM_METAL_EXT + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceFragmentDensityMapFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT: + dump_string(settings, "VkPhysicalDeviceFragmentDensityMapPropertiesEXT"); + break; + + case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: + dump_string(settings, "VkRenderPassFragmentDensityMapCreateInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: + dump_string(settings, "VkRenderingFragmentDensityMapAttachmentInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: + dump_string(settings, "VkPhysicalDeviceShaderCoreProperties2AMD"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: + dump_string(settings, "VkPhysicalDeviceCoherentMemoryFeaturesAMD"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT: + dump_string(settings, "VkPhysicalDeviceMemoryBudgetPropertiesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceMemoryPriorityFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT: + dump_string(settings, "VkMemoryPriorityAllocateInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: + dump_string(settings, "VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceBufferDeviceAddressFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: + dump_string(settings, "VkBufferDeviceAddressCreateInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT: + dump_string(settings, "VkValidationFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV: + dump_string(settings, "VkCooperativeMatrixPropertiesNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: + dump_string(settings, "VkPhysicalDeviceCooperativeMatrixFeaturesNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV: + dump_string(settings, "VkPhysicalDeviceCooperativeMatrixPropertiesNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: + dump_string(settings, "VkPhysicalDeviceCoverageReductionModeFeaturesNV"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV: + dump_string(settings, "VkPipelineCoverageReductionStateCreateInfoNV"); + break; + + case VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV: + dump_string(settings, "VkFramebufferMixedSamplesCombinationNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceYcbcrImageArraysFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceProvokingVertexFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: + dump_string(settings, "VkPhysicalDeviceProvokingVertexPropertiesEXT"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT: + dump_string(settings, "VkPipelineRasterizationProvokingVertexStateCreateInfoEXT"); + break; +#if defined(VK_USE_PLATFORM_WIN32_KHR) + + case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT: + dump_string(settings, "VkSurfaceFullScreenExclusiveInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT: + dump_string(settings, "VkSurfaceCapabilitiesFullScreenExclusiveEXT"); + break; + + case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT: + dump_string(settings, "VkSurfaceFullScreenExclusiveWin32InfoEXT"); + break; +#endif // VK_USE_PLATFORM_WIN32_KHR + + case VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT: + dump_string(settings, "VkHeadlessSurfaceCreateInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceShaderAtomicFloatFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceExtendedDynamicStateFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceMapMemoryPlacedFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT: + dump_string(settings, "VkPhysicalDeviceMapMemoryPlacedPropertiesEXT"); + break; + + case VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT: + dump_string(settings, "VkMemoryMapPlacedInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: + dump_string(settings, "VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: + dump_string(settings, "VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV"); + break; + + case VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV: + dump_string(settings, "VkGraphicsShaderGroupCreateInfoNV"); + break; + + case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV: + dump_string(settings, "VkGraphicsPipelineShaderGroupsCreateInfoNV"); + break; + + case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV: + dump_string(settings, "VkIndirectCommandsLayoutTokenNV"); + break; + + case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV: + dump_string(settings, "VkIndirectCommandsLayoutCreateInfoNV"); + break; + + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV: + dump_string(settings, "VkGeneratedCommandsInfoNV"); + break; + + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV: + dump_string(settings, "VkGeneratedCommandsMemoryRequirementsInfoNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: + dump_string(settings, "VkPhysicalDeviceInheritedViewportScissorFeaturesNV"); + break; + + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV: + dump_string(settings, "VkCommandBufferInheritanceViewportScissorInfoNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: + dump_string(settings, "VkRenderPassTransformBeginInfoQCOM"); + break; + + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM: + dump_string(settings, "VkCommandBufferInheritanceRenderPassTransformInfoQCOM"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceDepthBiasControlFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT: + dump_string(settings, "VkDepthBiasInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT: + dump_string(settings, "VkDepthBiasRepresentationInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceDeviceMemoryReportFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT: + dump_string(settings, "VkDeviceMemoryReportCallbackDataEXT"); + break; + + case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT: + dump_string(settings, "VkDeviceDeviceMemoryReportCreateInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT: + dump_string(settings, "VkPhysicalDeviceCustomBorderColorPropertiesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceCustomBorderColorFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: + dump_string(settings, "VkPhysicalDevicePresentBarrierFeaturesNV"); + break; + + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV: + dump_string(settings, "VkSurfaceCapabilitiesPresentBarrierNV"); + break; + + case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV: + dump_string(settings, "VkSwapchainPresentBarrierCreateInfoNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: + dump_string(settings, "VkPhysicalDeviceDiagnosticsConfigFeaturesNV"); + break; + + case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV: + dump_string(settings, "VkDeviceDiagnosticsConfigCreateInfoNV"); + break; +#if defined(VK_ENABLE_BETA_EXTENSIONS) + + case VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV: + dump_string(settings, "VkCudaModuleCreateInfoNV"); + break; + + case VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV: + dump_string(settings, "VkCudaFunctionCreateInfoNV"); + break; + + case VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV: + dump_string(settings, "VkCudaLaunchInfoNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV: + dump_string(settings, "VkPhysicalDeviceCudaKernelLaunchFeaturesNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV: + dump_string(settings, "VkPhysicalDeviceCudaKernelLaunchPropertiesNV"); + break; +#endif // VK_ENABLE_BETA_EXTENSIONS + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM: + dump_string(settings, "VkPhysicalDeviceTileShadingFeaturesQCOM"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM: + dump_string(settings, "VkPhysicalDeviceTileShadingPropertiesQCOM"); + break; + + case VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM: + dump_string(settings, "VkRenderPassTileShadingCreateInfoQCOM"); + break; + + case VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM: + dump_string(settings, "VkPerTileBeginInfoQCOM"); + break; + + case VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM: + dump_string(settings, "VkPerTileEndInfoQCOM"); + break; + + case VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM: + dump_string(settings, "VkDispatchTileInfoQCOM"); + break; + + case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV: + dump_string(settings, "VkQueryLowLatencySupportNV"); + break; +#if defined(VK_USE_PLATFORM_METAL_EXT) + + case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT: + dump_string(settings, "VkExportMetalObjectCreateInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT: + dump_string(settings, "VkExportMetalObjectsInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT: + dump_string(settings, "VkExportMetalDeviceInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT: + dump_string(settings, "VkExportMetalCommandQueueInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT: + dump_string(settings, "VkExportMetalBufferInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT: + dump_string(settings, "VkImportMetalBufferInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT: + dump_string(settings, "VkExportMetalTextureInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT: + dump_string(settings, "VkImportMetalTextureInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT: + dump_string(settings, "VkExportMetalIOSurfaceInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT: + dump_string(settings, "VkImportMetalIOSurfaceInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT: + dump_string(settings, "VkExportMetalSharedEventInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT: + dump_string(settings, "VkImportMetalSharedEventInfoEXT"); + break; +#endif // VK_USE_PLATFORM_METAL_EXT + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT: + dump_string(settings, "VkPhysicalDeviceDescriptorBufferPropertiesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT: + dump_string(settings, "VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceDescriptorBufferFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT: + dump_string(settings, "VkDescriptorAddressInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT: + dump_string(settings, "VkDescriptorBufferBindingInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT: + dump_string(settings, "VkDescriptorBufferBindingPushDescriptorBufferHandleEXT"); + break; + + case VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT: + dump_string(settings, "VkDescriptorGetInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: + dump_string(settings, "VkBufferCaptureDescriptorDataInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: + dump_string(settings, "VkImageCaptureDescriptorDataInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: + dump_string(settings, "VkImageViewCaptureDescriptorDataInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: + dump_string(settings, "VkSamplerCaptureDescriptorDataInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: + dump_string(settings, "VkOpaqueCaptureDescriptorDataCreateInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: + dump_string(settings, "VkAccelerationStructureCaptureDescriptorDataInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: + dump_string(settings, "VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT"); + break; + + case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: + dump_string(settings, "VkGraphicsPipelineLibraryCreateInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD: + dump_string(settings, "VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: + dump_string(settings, "VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV: + dump_string(settings, "VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV: + dump_string(settings, "VkPipelineFragmentShadingRateEnumStateCreateInfoNV"); + break; + + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV: + dump_string(settings, "VkAccelerationStructureGeometryMotionTrianglesDataNV"); + break; + + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV: + dump_string(settings, "VkAccelerationStructureMotionInfoNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: + dump_string(settings, "VkPhysicalDeviceRayTracingMotionBlurFeaturesNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceFragmentDensityMap2FeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT: + dump_string(settings, "VkPhysicalDeviceFragmentDensityMap2PropertiesEXT"); + break; + + case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM: + dump_string(settings, "VkCopyCommandTransformInfoQCOM"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceImageCompressionControlFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: + dump_string(settings, "VkImageCompressionControlEXT"); + break; + + case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT: + dump_string(settings, "VkImageCompressionPropertiesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: + dump_string(settings, "VkPhysicalDevice4444FormatsFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceFaultFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT: + dump_string(settings, "VkDeviceFaultCountsEXT"); + break; + + case VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT: + dump_string(settings, "VkDeviceFaultInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT"); + break; +#if defined(VK_USE_PLATFORM_DIRECTFB_EXT) + + case VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT: + dump_string(settings, "VkDirectFBSurfaceCreateInfoEXT"); + break; +#endif // VK_USE_PLATFORM_DIRECTFB_EXT + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT: + dump_string(settings, "VkMutableDescriptorTypeCreateInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT: + dump_string(settings, "VkVertexInputBindingDescription2EXT"); + break; + + case VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT: + dump_string(settings, "VkVertexInputAttributeDescription2EXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT: + dump_string(settings, "VkPhysicalDeviceDrmPropertiesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceAddressBindingReportFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT: + dump_string(settings, "VkDeviceAddressBindingCallbackDataEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceDepthClipControlFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT: + dump_string(settings, "VkPipelineViewportDepthClipControlCreateInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: + dump_string(settings, "VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT"); + break; +#if defined(VK_USE_PLATFORM_FUCHSIA) + + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA: + dump_string(settings, "VkImportMemoryZirconHandleInfoFUCHSIA"); + break; + + case VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA: + dump_string(settings, "VkMemoryZirconHandlePropertiesFUCHSIA"); + break; + + case VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA: + dump_string(settings, "VkMemoryGetZirconHandleInfoFUCHSIA"); + break; + + case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA: + dump_string(settings, "VkImportSemaphoreZirconHandleInfoFUCHSIA"); + break; + + case VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA: + dump_string(settings, "VkSemaphoreGetZirconHandleInfoFUCHSIA"); + break; + + case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA: + dump_string(settings, "VkBufferCollectionCreateInfoFUCHSIA"); + break; + + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA: + dump_string(settings, "VkImportMemoryBufferCollectionFUCHSIA"); + break; + + case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA: + dump_string(settings, "VkBufferCollectionImageCreateInfoFUCHSIA"); + break; + + case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA: + dump_string(settings, "VkBufferCollectionConstraintsInfoFUCHSIA"); + break; + + case VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA: + dump_string(settings, "VkBufferConstraintsInfoFUCHSIA"); + break; + + case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA: + dump_string(settings, "VkBufferCollectionBufferCreateInfoFUCHSIA"); + break; + + case VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA: + dump_string(settings, "VkSysmemColorSpaceFUCHSIA"); + break; + + case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA: + dump_string(settings, "VkBufferCollectionPropertiesFUCHSIA"); + break; + + case VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA: + dump_string(settings, "VkImageFormatConstraintsInfoFUCHSIA"); + break; + + case VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA: + dump_string(settings, "VkImageConstraintsInfoFUCHSIA"); + break; +#endif // VK_USE_PLATFORM_FUCHSIA + + case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI: + dump_string(settings, "VkSubpassShadingPipelineCreateInfoHUAWEI"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: + dump_string(settings, "VkPhysicalDeviceSubpassShadingFeaturesHUAWEI"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI: + dump_string(settings, "VkPhysicalDeviceSubpassShadingPropertiesHUAWEI"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: + dump_string(settings, "VkPhysicalDeviceInvocationMaskFeaturesHUAWEI"); + break; + + case VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV: + dump_string(settings, "VkMemoryGetRemoteAddressInfoNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV: + dump_string(settings, "VkPhysicalDeviceExternalMemoryRDMAFeaturesNV"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT: + dump_string(settings, "VkPipelinePropertiesIdentifierEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: + dump_string(settings, "VkPhysicalDevicePipelinePropertiesFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceFrameBoundaryFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT: + dump_string(settings, "VkFrameBoundaryEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT: + dump_string(settings, "VkSubpassResolvePerformanceQueryEXT"); + break; + + case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT: + dump_string(settings, "VkMultisampledRenderToSingleSampledInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceExtendedDynamicState2FeaturesEXT"); + break; +#if defined(VK_USE_PLATFORM_SCREEN_QNX) + + case VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX: + dump_string(settings, "VkScreenSurfaceCreateInfoQNX"); + break; +#endif // VK_USE_PLATFORM_SCREEN_QNX + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceColorWriteEnableFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT: + dump_string(settings, "VkPipelineColorWriteCreateInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: + dump_string(settings, "VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE: + dump_string(settings, "VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE: + dump_string(settings, "VkVideoEncodeRgbConversionCapabilitiesVALVE"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE: + dump_string(settings, "VkVideoEncodeProfileRgbConversionInfoVALVE"); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE: + dump_string(settings, "VkVideoEncodeSessionRgbConversionCreateInfoVALVE"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceImageViewMinLodFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT: + dump_string(settings, "VkImageViewMinLodCreateInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceMultiDrawFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT: + dump_string(settings, "VkPhysicalDeviceMultiDrawPropertiesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceImage2DViewOf3DFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceShaderTileImageFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT: + dump_string(settings, "VkPhysicalDeviceShaderTileImagePropertiesEXT"); + break; + + case VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT: + dump_string(settings, "VkMicromapBuildInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT: + dump_string(settings, "VkMicromapCreateInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceOpacityMicromapFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT: + dump_string(settings, "VkPhysicalDeviceOpacityMicromapPropertiesEXT"); + break; + + case VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT: + dump_string(settings, "VkMicromapVersionInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT: + dump_string(settings, "VkCopyMicromapToMemoryInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT: + dump_string(settings, "VkCopyMemoryToMicromapInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT: + dump_string(settings, "VkCopyMicromapInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT: + dump_string(settings, "VkMicromapBuildSizesInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT: + dump_string(settings, "VkAccelerationStructureTrianglesOpacityMicromapEXT"); + break; +#if defined(VK_ENABLE_BETA_EXTENSIONS) + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV: + dump_string(settings, "VkPhysicalDeviceDisplacementMicromapFeaturesNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV: + dump_string(settings, "VkPhysicalDeviceDisplacementMicromapPropertiesNV"); + break; + + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV: + dump_string(settings, "VkAccelerationStructureTrianglesDisplacementMicromapNV"); + break; +#endif // VK_ENABLE_BETA_EXTENSIONS + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI: + dump_string(settings, "VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI: + dump_string(settings, "VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI: + dump_string(settings, "VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceBorderColorSwizzleFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT: + dump_string(settings, "VkSamplerBorderColorComponentMappingCreateInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: + dump_string(settings, "VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM: + dump_string(settings, "VkPhysicalDeviceShaderCorePropertiesARM"); + break; + + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM: + dump_string(settings, "VkDeviceQueueShaderCoreControlCreateInfoARM"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM: + dump_string(settings, "VkPhysicalDeviceSchedulingControlsFeaturesARM"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM: + dump_string(settings, "VkPhysicalDeviceSchedulingControlsPropertiesARM"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT: + dump_string(settings, "VkImageViewSlicedCreateInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: + dump_string(settings, "VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE"); + break; + + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE: + dump_string(settings, "VkDescriptorSetBindingReferenceVALVE"); + break; + + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE: + dump_string(settings, "VkDescriptorSetLayoutHostMappingInfoVALVE"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM: + dump_string(settings, "VkPhysicalDeviceRenderPassStripedFeaturesARM"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM: + dump_string(settings, "VkPhysicalDeviceRenderPassStripedPropertiesARM"); + break; + + case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM: + dump_string(settings, "VkRenderPassStripeInfoARM"); + break; + + case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM: + dump_string(settings, "VkRenderPassStripeBeginInfoARM"); + break; + + case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM: + dump_string(settings, "VkRenderPassStripeSubmitInfoARM"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT: + dump_string(settings, "VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT"); + break; + + case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT: + dump_string(settings, "VkRenderPassFragmentDensityMapOffsetEndInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: + dump_string(settings, "VkPhysicalDeviceCopyMemoryIndirectFeaturesNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceMemoryDecompressionFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT: + dump_string(settings, "VkPhysicalDeviceMemoryDecompressionPropertiesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV: + dump_string(settings, "VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV"); + break; + + case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV: + dump_string(settings, "VkComputePipelineIndirectBufferInfoNV"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV: + dump_string(settings, "VkPipelineIndirectDeviceAddressInfoNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV: + dump_string(settings, "VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV"); + break; + + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV: + dump_string(settings, "VkAccelerationStructureGeometryLinearSweptSpheresDataNV"); + break; + + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV: + dump_string(settings, "VkAccelerationStructureGeometrySpheresDataNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: + dump_string(settings, "VkPhysicalDeviceLinearColorAttachmentFeaturesNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM: + dump_string(settings, "VkImageViewSampleWeightCreateInfoQCOM"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: + dump_string(settings, "VkPhysicalDeviceImageProcessingFeaturesQCOM"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM: + dump_string(settings, "VkPhysicalDeviceImageProcessingPropertiesQCOM"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceNestedCommandBufferFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT: + dump_string(settings, "VkPhysicalDeviceNestedCommandBufferPropertiesEXT"); + break; +#if defined(VK_USE_PLATFORM_OHOS) + + case VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS: + dump_string(settings, "VkNativeBufferUsageOHOS"); + break; + + case VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS: + dump_string(settings, "VkNativeBufferPropertiesOHOS"); + break; + + case VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS: + dump_string(settings, "VkNativeBufferFormatPropertiesOHOS"); + break; + + case VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS: + dump_string(settings, "VkImportNativeBufferInfoOHOS"); + break; + + case VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS: + dump_string(settings, "VkMemoryGetNativeBufferInfoOHOS"); + break; + + case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS: + dump_string(settings, "VkExternalFormatOHOS"); + break; +#endif // VK_USE_PLATFORM_OHOS + + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT: + dump_string(settings, "VkExternalMemoryAcquireUnmodifiedEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT: + dump_string(settings, "VkPhysicalDeviceExtendedDynamicState3PropertiesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT: + dump_string(settings, "VkRenderPassCreationControlEXT"); + break; + + case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT: + dump_string(settings, "VkRenderPassCreationFeedbackCreateInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT: + dump_string(settings, "VkRenderPassSubpassFeedbackCreateInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG: + dump_string(settings, "VkDirectDriverLoadingInfoLUNARG"); + break; + + case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG: + dump_string(settings, "VkDirectDriverLoadingListLUNARG"); + break; + + case VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM: + dump_string(settings, "VkTensorDescriptionARM"); + break; + + case VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM: + dump_string(settings, "VkTensorCreateInfoARM"); + break; + + case VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM: + dump_string(settings, "VkTensorMemoryRequirementsInfoARM"); + break; + + case VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM: + dump_string(settings, "VkBindTensorMemoryInfoARM"); + break; + + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM: + dump_string(settings, "VkWriteDescriptorSetTensorARM"); + break; + + case VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM: + dump_string(settings, "VkTensorFormatPropertiesARM"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM: + dump_string(settings, "VkPhysicalDeviceTensorPropertiesARM"); + break; + + case VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM: + dump_string(settings, "VkTensorMemoryBarrierARM"); + break; + + case VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM: + dump_string(settings, "VkTensorDependencyInfoARM"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM: + dump_string(settings, "VkPhysicalDeviceTensorFeaturesARM"); + break; + + case VK_STRUCTURE_TYPE_DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM: + dump_string(settings, "VkDeviceTensorMemoryRequirementsARM"); + break; + + case VK_STRUCTURE_TYPE_TENSOR_COPY_ARM: + dump_string(settings, "VkTensorCopyARM"); + break; + + case VK_STRUCTURE_TYPE_COPY_TENSOR_INFO_ARM: + dump_string(settings, "VkCopyTensorInfoARM"); + break; + + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM: + dump_string(settings, "VkMemoryDedicatedAllocateInfoTensorARM"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM: + dump_string(settings, "VkPhysicalDeviceExternalTensorInfoARM"); + break; + + case VK_STRUCTURE_TYPE_EXTERNAL_TENSOR_PROPERTIES_ARM: + dump_string(settings, "VkExternalTensorPropertiesARM"); + break; + + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM: + dump_string(settings, "VkExternalMemoryTensorCreateInfoARM"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM: + dump_string(settings, "VkPhysicalDeviceDescriptorBufferTensorFeaturesARM"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM: + dump_string(settings, "VkPhysicalDeviceDescriptorBufferTensorPropertiesARM"); + break; + + case VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM: + dump_string(settings, "VkDescriptorGetTensorInfoARM"); + break; + + case VK_STRUCTURE_TYPE_TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM: + dump_string(settings, "VkTensorCaptureDescriptorDataInfoARM"); + break; + + case VK_STRUCTURE_TYPE_TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM: + dump_string(settings, "VkTensorViewCaptureDescriptorDataInfoARM"); + break; + + case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM: + dump_string(settings, "VkFrameBoundaryTensorsARM"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT: + dump_string(settings, "VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT: + dump_string(settings, "VkPipelineShaderStageModuleIdentifierCreateInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT: + dump_string(settings, "VkShaderModuleIdentifierEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: + dump_string(settings, "VkPhysicalDeviceOpticalFlowFeaturesNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV: + dump_string(settings, "VkPhysicalDeviceOpticalFlowPropertiesNV"); + break; + + case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: + dump_string(settings, "VkOpticalFlowImageFormatInfoNV"); + break; + + case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV: + dump_string(settings, "VkOpticalFlowImageFormatPropertiesNV"); + break; + + case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV: + dump_string(settings, "VkOpticalFlowSessionCreateInfoNV"); + break; + + case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV: + dump_string(settings, "VkOpticalFlowSessionCreatePrivateDataInfoNV"); + break; + + case VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV: + dump_string(settings, "VkOpticalFlowExecuteInfoNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceLegacyDitheringFeaturesEXT"); + break; +#if defined(VK_USE_PLATFORM_ANDROID_KHR) + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID: + dump_string(settings, "VkPhysicalDeviceExternalFormatResolveFeaturesANDROID"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID: + dump_string(settings, "VkPhysicalDeviceExternalFormatResolvePropertiesANDROID"); + break; + + case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID: + dump_string(settings, "VkAndroidHardwareBufferFormatResolvePropertiesANDROID"); + break; +#endif // VK_USE_PLATFORM_ANDROID_KHR + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD: + dump_string(settings, "VkPhysicalDeviceAntiLagFeaturesAMD"); + break; + + case VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD: + dump_string(settings, "VkAntiLagPresentationInfoAMD"); + break; + + case VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD: + dump_string(settings, "VkAntiLagDataAMD"); + break; +#if defined(VK_ENABLE_BETA_EXTENSIONS) + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX: + dump_string(settings, "VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX"); + break; + + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA_AMDX: + dump_string(settings, "VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX"); + break; +#endif // VK_ENABLE_BETA_EXTENSIONS + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceShaderObjectFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT: + dump_string(settings, "VkPhysicalDeviceShaderObjectPropertiesEXT"); + break; + + case VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT: + dump_string(settings, "VkShaderCreateInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: + dump_string(settings, "VkPhysicalDeviceTilePropertiesFeaturesQCOM"); + break; + + case VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM: + dump_string(settings, "VkTilePropertiesQCOM"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC: + dump_string(settings, "VkPhysicalDeviceAmigoProfilingFeaturesSEC"); + break; + + case VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC: + dump_string(settings, "VkAmigoProfilingSubmitInfoSEC"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: + dump_string(settings, "VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV: + dump_string(settings, "VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: + dump_string(settings, "VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV: + dump_string(settings, "VkPhysicalDeviceCooperativeVectorPropertiesNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV: + dump_string(settings, "VkPhysicalDeviceCooperativeVectorFeaturesNV"); + break; + + case VK_STRUCTURE_TYPE_COOPERATIVE_VECTOR_PROPERTIES_NV: + dump_string(settings, "VkCooperativeVectorPropertiesNV"); + break; + + case VK_STRUCTURE_TYPE_CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV: + dump_string(settings, "VkConvertCooperativeVectorMatrixInfoNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV: + dump_string(settings, "VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV: + dump_string(settings, "VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT: + dump_string(settings, "VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT"); + break; + + case VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT: + dump_string(settings, "VkLayerSettingsCreateInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: + dump_string(settings, "VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM: + dump_string(settings, "VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT: + dump_string(settings, "VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV: + dump_string(settings, "VkLatencySleepModeInfoNV"); + break; + + case VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV: + dump_string(settings, "VkLatencySleepInfoNV"); + break; + + case VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV: + dump_string(settings, "VkSetLatencyMarkerInfoNV"); + break; + + case VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV: + dump_string(settings, "VkLatencyTimingsFrameReportNV"); + break; + + case VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV: + dump_string(settings, "VkGetLatencyMarkerInfoNV"); + break; + + case VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV: + dump_string(settings, "VkLatencySubmissionPresentIdNV"); + break; + + case VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV: + dump_string(settings, "VkSwapchainLatencyCreateInfoNV"); + break; + + case VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV: + dump_string(settings, "VkOutOfBandQueueTypeInfoNV"); + break; + + case VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV: + dump_string(settings, "VkLatencySurfaceCapabilitiesNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM: + dump_string(settings, "VkPhysicalDeviceDataGraphFeaturesARM"); + break; + + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_ARM: + dump_string(settings, "VkDataGraphPipelineConstantARM"); + break; + + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_ARM: + dump_string(settings, "VkDataGraphPipelineResourceInfoARM"); + break; + + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO_ARM: + dump_string(settings, "VkDataGraphPipelineCompilerControlCreateInfoARM"); + break; + + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CREATE_INFO_ARM: + dump_string(settings, "VkDataGraphPipelineCreateInfoARM"); + break; + + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM: + dump_string(settings, "VkDataGraphPipelineShaderModuleCreateInfoARM"); + break; + + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_CREATE_INFO_ARM: + dump_string(settings, "VkDataGraphPipelineSessionCreateInfoARM"); + break; + + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENTS_INFO_ARM: + dump_string(settings, "VkDataGraphPipelineSessionBindPointRequirementsInfoARM"); + break; + + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENT_ARM: + dump_string(settings, "VkDataGraphPipelineSessionBindPointRequirementARM"); + break; + + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_MEMORY_REQUIREMENTS_INFO_ARM: + dump_string(settings, "VkDataGraphPipelineSessionMemoryRequirementsInfoARM"); + break; + + case VK_STRUCTURE_TYPE_BIND_DATA_GRAPH_PIPELINE_SESSION_MEMORY_INFO_ARM: + dump_string(settings, "VkBindDataGraphPipelineSessionMemoryInfoARM"); + break; + + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_INFO_ARM: + dump_string(settings, "VkDataGraphPipelineInfoARM"); + break; + + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_PROPERTY_QUERY_RESULT_ARM: + dump_string(settings, "VkDataGraphPipelinePropertyQueryResultARM"); + break; + + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO_ARM: + dump_string(settings, "VkDataGraphPipelineIdentifierCreateInfoARM"); + break; + + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_DISPATCH_INFO_ARM: + dump_string(settings, "VkDataGraphPipelineDispatchInfoARM"); + break; + + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROPERTIES_ARM: + dump_string(settings, "VkQueueFamilyDataGraphPropertiesARM"); + break; + + case VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM: + dump_string(settings, "VkDataGraphProcessingEngineCreateInfoARM"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_INFO_ARM: + dump_string(settings, "VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM"); + break; + + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_PROPERTIES_ARM: + dump_string(settings, "VkQueueFamilyDataGraphProcessingEnginePropertiesARM"); + break; + + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM: + dump_string(settings, "VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM: + dump_string(settings, "VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM"); + break; + + case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM: + dump_string(settings, "VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV: + dump_string(settings, "VkPhysicalDevicePerStageDescriptorSetFeaturesNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM: + dump_string(settings, "VkPhysicalDeviceImageProcessing2FeaturesQCOM"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM: + dump_string(settings, "VkPhysicalDeviceImageProcessing2PropertiesQCOM"); + break; + + case VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM: + dump_string(settings, "VkSamplerBlockMatchWindowCreateInfoQCOM"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM: + dump_string(settings, "VkPhysicalDeviceCubicWeightsFeaturesQCOM"); + break; + + case VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM: + dump_string(settings, "VkSamplerCubicWeightsCreateInfoQCOM"); + break; + + case VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM: + dump_string(settings, "VkBlitImageCubicWeightsInfoQCOM"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM: + dump_string(settings, "VkPhysicalDeviceYcbcrDegammaFeaturesQCOM"); + break; + + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM: + dump_string(settings, "VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM: + dump_string(settings, "VkPhysicalDeviceCubicClampFeaturesQCOM"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT"); + break; +#if defined(VK_USE_PLATFORM_SCREEN_QNX) + + case VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX: + dump_string(settings, "VkScreenBufferPropertiesQNX"); + break; + + case VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX: + dump_string(settings, "VkScreenBufferFormatPropertiesQNX"); + break; + + case VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX: + dump_string(settings, "VkImportScreenBufferInfoQNX"); + break; + + case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX: + dump_string(settings, "VkExternalFormatQNX"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX: + dump_string(settings, "VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX"); + break; +#endif // VK_USE_PLATFORM_SCREEN_QNX + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT: + dump_string(settings, "VkPhysicalDeviceLayeredDriverPropertiesMSFT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV: + dump_string(settings, "VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM: + dump_string(settings, "VkPhysicalDeviceTileMemoryHeapFeaturesQCOM"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM: + dump_string(settings, "VkPhysicalDeviceTileMemoryHeapPropertiesQCOM"); + break; + + case VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM: + dump_string(settings, "VkTileMemoryRequirementsQCOM"); + break; + + case VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM: + dump_string(settings, "VkTileMemoryBindInfoQCOM"); + break; + + case VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM: + dump_string(settings, "VkTileMemorySizeInfoQCOM"); + break; + + case VK_STRUCTURE_TYPE_DECOMPRESS_MEMORY_INFO_EXT: + dump_string(settings, "VkDecompressMemoryInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV: + dump_string(settings, "VkDisplaySurfaceStereoCreateInfoNV"); + break; + + case VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV: + dump_string(settings, "VkDisplayModeStereoPropertiesNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV: + dump_string(settings, "VkPhysicalDeviceRawAccessChainsFeaturesNV"); + break; + + case VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV: + dump_string(settings, "VkExternalComputeQueueDeviceCreateInfoNV"); + break; + + case VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV: + dump_string(settings, "VkExternalComputeQueueCreateInfoNV"); + break; + + case VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV: + dump_string(settings, "VkExternalComputeQueueDataParamsNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV: + dump_string(settings, "VkPhysicalDeviceExternalComputeQueuePropertiesNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV: + dump_string(settings, "VkPhysicalDeviceCommandBufferInheritanceFeaturesNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV: + dump_string(settings, "VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceShaderFloat8FeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV: + dump_string(settings, "VkPhysicalDeviceRayTracingValidationFeaturesNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV: + dump_string(settings, "VkPhysicalDeviceClusterAccelerationStructureFeaturesNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV: + dump_string(settings, "VkPhysicalDeviceClusterAccelerationStructurePropertiesNV"); + break; + + case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV: + dump_string(settings, "VkClusterAccelerationStructureClustersBottomLevelInputNV"); + break; + + case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV: + dump_string(settings, "VkClusterAccelerationStructureTriangleClusterInputNV"); + break; + + case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV: + dump_string(settings, "VkClusterAccelerationStructureMoveObjectsInputNV"); + break; + + case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV: + dump_string(settings, "VkClusterAccelerationStructureInputInfoNV"); + break; + + case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV: + dump_string(settings, "VkClusterAccelerationStructureCommandsInfoNV"); + break; + + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR: + dump_string(settings, "VkAccelerationStructureBuildSizesInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV: + dump_string(settings, "VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV: + dump_string(settings, "VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV: + dump_string(settings, "VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV"); + break; + + case VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV: + dump_string(settings, "VkPartitionedAccelerationStructureFlagsNV"); + break; + + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV: + dump_string(settings, "VkWriteDescriptorSetPartitionedAccelerationStructureNV"); + break; + + case VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV: + dump_string(settings, "VkPartitionedAccelerationStructureInstancesInputNV"); + break; + + case VK_STRUCTURE_TYPE_BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV: + dump_string(settings, "VkBuildPartitionedAccelerationStructureInfoNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT: + dump_string(settings, "VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT"); + break; + + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT: + dump_string(settings, "VkGeneratedCommandsMemoryRequirementsInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT: + dump_string(settings, "VkIndirectExecutionSetPipelineInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT: + dump_string(settings, "VkIndirectExecutionSetShaderLayoutInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT: + dump_string(settings, "VkIndirectExecutionSetShaderInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT: + dump_string(settings, "VkIndirectExecutionSetCreateInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT: + dump_string(settings, "VkGeneratedCommandsInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT: + dump_string(settings, "VkWriteIndirectExecutionSetPipelineEXT"); + break; + + case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT: + dump_string(settings, "VkIndirectCommandsLayoutTokenEXT"); + break; + + case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT: + dump_string(settings, "VkIndirectCommandsLayoutCreateInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT: + dump_string(settings, "VkGeneratedCommandsPipelineInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT: + dump_string(settings, "VkGeneratedCommandsShaderInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT: + dump_string(settings, "VkWriteIndirectExecutionSetShaderEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA: + dump_string(settings, "VkPhysicalDeviceImageAlignmentControlFeaturesMESA"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA: + dump_string(settings, "VkPhysicalDeviceImageAlignmentControlPropertiesMESA"); + break; + + case VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA: + dump_string(settings, "VkImageAlignmentControlCreateInfoMESA"); + break; + + case VK_STRUCTURE_TYPE_PUSH_CONSTANT_BANK_INFO_NV: + dump_string(settings, "VkPushConstantBankInfoNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_FEATURES_NV: + dump_string(settings, "VkPhysicalDevicePushConstantBankFeaturesNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_PROPERTIES_NV: + dump_string(settings, "VkPhysicalDevicePushConstantBankPropertiesNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_EXT: + dump_string(settings, "VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceDepthClampControlFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT: + dump_string(settings, "VkPipelineViewportDepthClampControlCreateInfoEXT"); + break; +#if defined(VK_USE_PLATFORM_OHOS) + + case VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS: + dump_string(settings, "VkSurfaceCreateInfoOHOS"); + break; +#endif // VK_USE_PLATFORM_OHOS + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI: + dump_string(settings, "VkPhysicalDeviceHdrVividFeaturesHUAWEI"); + break; + + case VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI: + dump_string(settings, "VkHdrVividDynamicMetadataHUAWEI"); + break; + + case VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV: + dump_string(settings, "VkCooperativeMatrixFlexibleDimensionsPropertiesNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV: + dump_string(settings, "VkPhysicalDeviceCooperativeMatrix2FeaturesNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV: + dump_string(settings, "VkPhysicalDeviceCooperativeMatrix2PropertiesNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM: + dump_string(settings, "VkPhysicalDevicePipelineOpacityMicromapFeaturesARM"); + break; +#if defined(VK_USE_PLATFORM_METAL_EXT) + + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT: + dump_string(settings, "VkImportMemoryMetalHandleInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_MEMORY_METAL_HANDLE_PROPERTIES_EXT: + dump_string(settings, "VkMemoryMetalHandlePropertiesEXT"); + break; + + case VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT: + dump_string(settings, "VkMemoryGetMetalHandleInfoEXT"); + break; +#endif // VK_USE_PLATFORM_METAL_EXT + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_FEATURES_ARM: + dump_string(settings, "VkPhysicalDevicePerformanceCountersByRegionFeaturesARM"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_PROPERTIES_ARM: + dump_string(settings, "VkPhysicalDevicePerformanceCountersByRegionPropertiesARM"); + break; + + case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_ARM: + dump_string(settings, "VkPerformanceCounterARM"); + break; + + case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_ARM: + dump_string(settings, "VkPerformanceCounterDescriptionARM"); + break; + + case VK_STRUCTURE_TYPE_RENDER_PASS_PERFORMANCE_COUNTERS_BY_REGION_BEGIN_INFO_ARM: + dump_string(settings, "VkRenderPassPerformanceCountersByRegionBeginInfoARM"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM: + dump_string(settings, "VkPhysicalDeviceFormatPackFeaturesARM"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE: + dump_string(settings, "VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE: + dump_string(settings, "VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE"); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE: + dump_string(settings, "VkPipelineFragmentDensityMapLayeredCreateInfoVALVE"); + break; +#if defined(VK_ENABLE_BETA_EXTENSIONS) + + case VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV: + dump_string(settings, "VkSetPresentConfigNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV: + dump_string(settings, "VkPhysicalDevicePresentMeteringFeaturesNV"); + break; +#endif // VK_ENABLE_BETA_EXTENSIONS + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceShader64BitIndexingFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceCustomResolveFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_BEGIN_CUSTOM_RESOLVE_INFO_EXT: + dump_string(settings, "VkBeginCustomResolveInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_CUSTOM_RESOLVE_CREATE_INFO_EXT: + dump_string(settings, "VkCustomResolveCreateInfoEXT"); + break; + + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO_QCOM: + dump_string(settings, "VkDataGraphPipelineBuiltinModelCreateInfoQCOM"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM: + dump_string(settings, "VkPhysicalDeviceDataGraphModelFeaturesQCOM"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceShaderLongVectorFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT: + dump_string(settings, "VkPhysicalDeviceShaderLongVectorPropertiesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC: + dump_string(settings, "VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_COMPUTE_OCCUPANCY_PRIORITY_PARAMETERS_NV: + dump_string(settings, "VkComputeOccupancyPriorityParametersNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES_NV: + dump_string(settings, "VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR: + dump_string(settings, "VkAccelerationStructureGeometryTrianglesDataKHR"); + break; + + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR: + dump_string(settings, "VkAccelerationStructureGeometryAabbsDataKHR"); + break; + + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR: + dump_string(settings, "VkAccelerationStructureGeometryInstancesDataKHR"); + break; + + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR: + dump_string(settings, "VkAccelerationStructureGeometryKHR"); + break; + + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR: + dump_string(settings, "VkAccelerationStructureBuildGeometryInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR: + dump_string(settings, "VkAccelerationStructureCreateInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: + dump_string(settings, "VkWriteDescriptorSetAccelerationStructureKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: + dump_string(settings, "VkPhysicalDeviceAccelerationStructureFeaturesKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR: + dump_string(settings, "VkPhysicalDeviceAccelerationStructurePropertiesKHR"); + break; + + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR: + dump_string(settings, "VkAccelerationStructureDeviceAddressInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR: + dump_string(settings, "VkAccelerationStructureVersionInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR: + dump_string(settings, "VkCopyAccelerationStructureToMemoryInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR: + dump_string(settings, "VkCopyMemoryToAccelerationStructureInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR: + dump_string(settings, "VkCopyAccelerationStructureInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR: + dump_string(settings, "VkRayTracingShaderGroupCreateInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR: + dump_string(settings, "VkRayTracingPipelineInterfaceCreateInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR: + dump_string(settings, "VkRayTracingPipelineCreateInfoKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: + dump_string(settings, "VkPhysicalDeviceRayTracingPipelineFeaturesKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: + dump_string(settings, "VkPhysicalDeviceRayTracingPipelinePropertiesKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: + dump_string(settings, "VkPhysicalDeviceRayQueryFeaturesKHR"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT: + dump_string(settings, "VkPhysicalDeviceMeshShaderFeaturesEXT"); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT: + dump_string(settings, "VkPhysicalDeviceMeshShaderPropertiesEXT"); + break; + + default: + dump_string(settings, "NULL"); + break; + } + dump_end(settings, OutputConstruct::value, indents); +} + +template +void dump_pNext_trampoline(const void* object, const ApiDumpSettings& settings, const char* type_name, const char* var_name, int indents) { + if (object == NULL) { + if constexpr (Format == ApiDumpFormat::Html || Format == ApiDumpFormat::Json) { + dump_nullptr(settings, type_name, var_name, indents); + } + return; + } + VkBaseInStructure base_struct{}; + memcpy(&base_struct, object, sizeof(VkBaseInStructure)); + switch (base_struct.sType) { + case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER: + dump_VkBufferMemoryBarrier(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkBufferMemoryBarrier*" : "VkBufferMemoryBarrier"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER: + dump_VkImageMemoryBarrier(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImageMemoryBarrier*" : "VkImageMemoryBarrier"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_MEMORY_BARRIER: + dump_VkMemoryBarrier(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryBarrier*" : "VkMemoryBarrier"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_APPLICATION_INFO: + dump_VkApplicationInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkApplicationInfo*" : "VkApplicationInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO: + dump_VkInstanceCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkInstanceCreateInfo*" : "VkInstanceCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO: + dump_VkDeviceQueueCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceQueueCreateInfo*" : "VkDeviceQueueCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO: + dump_VkDeviceCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceCreateInfo*" : "VkDeviceCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SUBMIT_INFO: + dump_VkSubmitInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSubmitInfo*" : "VkSubmitInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE: + dump_VkMappedMemoryRange(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkMappedMemoryRange*" : "VkMappedMemoryRange"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: + dump_VkMemoryAllocateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryAllocateInfo*" : "VkMemoryAllocateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_BIND_SPARSE_INFO: + dump_VkBindSparseInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkBindSparseInfo*" : "VkBindSparseInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_FENCE_CREATE_INFO: + dump_VkFenceCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkFenceCreateInfo*" : "VkFenceCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO: + dump_VkSemaphoreCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSemaphoreCreateInfo*" : "VkSemaphoreCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO: + dump_VkQueryPoolCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkQueryPoolCreateInfo*" : "VkQueryPoolCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO: + dump_VkBufferCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkBufferCreateInfo*" : "VkBufferCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO: + dump_VkImageCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImageCreateInfo*" : "VkImageCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO: + dump_VkImageViewCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImageViewCreateInfo*" : "VkImageViewCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO: + dump_VkCommandPoolCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCommandPoolCreateInfo*" : "VkCommandPoolCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO: + dump_VkCommandBufferAllocateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCommandBufferAllocateInfo*" : "VkCommandBufferAllocateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO: + dump_VkCommandBufferInheritanceInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCommandBufferInheritanceInfo*" : "VkCommandBufferInheritanceInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO: + dump_VkCommandBufferBeginInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCommandBufferBeginInfo*" : "VkCommandBufferBeginInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_EVENT_CREATE_INFO: + dump_VkEventCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkEventCreateInfo*" : "VkEventCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO: + dump_VkBufferViewCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkBufferViewCreateInfo*" : "VkBufferViewCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: + dump_VkShaderModuleCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkShaderModuleCreateInfo*" : "VkShaderModuleCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO: + dump_VkPipelineCacheCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineCacheCreateInfo*" : "VkPipelineCacheCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO: + dump_VkPipelineShaderStageCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineShaderStageCreateInfo*" : "VkPipelineShaderStageCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO: + dump_VkComputePipelineCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkComputePipelineCreateInfo*" : "VkComputePipelineCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: + dump_VkPipelineLayoutCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineLayoutCreateInfo*" : "VkPipelineLayoutCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO: + dump_VkSamplerCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSamplerCreateInfo*" : "VkSamplerCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET: + dump_VkCopyDescriptorSet(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCopyDescriptorSet*" : "VkCopyDescriptorSet"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO: + dump_VkDescriptorPoolCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDescriptorPoolCreateInfo*" : "VkDescriptorPoolCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO: + dump_VkDescriptorSetAllocateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDescriptorSetAllocateInfo*" : "VkDescriptorSetAllocateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO: + dump_VkDescriptorSetLayoutCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDescriptorSetLayoutCreateInfo*" : "VkDescriptorSetLayoutCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET: + dump_VkWriteDescriptorSet(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkWriteDescriptorSet*" : "VkWriteDescriptorSet"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO: + dump_VkPipelineVertexInputStateCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineVertexInputStateCreateInfo*" : "VkPipelineVertexInputStateCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO: + dump_VkPipelineInputAssemblyStateCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineInputAssemblyStateCreateInfo*" : "VkPipelineInputAssemblyStateCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO: + dump_VkPipelineTessellationStateCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineTessellationStateCreateInfo*" : "VkPipelineTessellationStateCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO: + dump_VkPipelineViewportStateCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineViewportStateCreateInfo*" : "VkPipelineViewportStateCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO: + dump_VkPipelineRasterizationStateCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineRasterizationStateCreateInfo*" : "VkPipelineRasterizationStateCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO: + dump_VkPipelineMultisampleStateCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineMultisampleStateCreateInfo*" : "VkPipelineMultisampleStateCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO: + dump_VkPipelineDepthStencilStateCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineDepthStencilStateCreateInfo*" : "VkPipelineDepthStencilStateCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO: + dump_VkPipelineColorBlendStateCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineColorBlendStateCreateInfo*" : "VkPipelineColorBlendStateCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO: + dump_VkPipelineDynamicStateCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineDynamicStateCreateInfo*" : "VkPipelineDynamicStateCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO: + dump_VkGraphicsPipelineCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkGraphicsPipelineCreateInfo*" : "VkGraphicsPipelineCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO: + dump_VkFramebufferCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkFramebufferCreateInfo*" : "VkFramebufferCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO: + dump_VkRenderPassCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderPassCreateInfo*" : "VkRenderPassCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO: + dump_VkRenderPassBeginInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderPassBeginInfo*" : "VkRenderPassBeginInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO: + dump_VkBindBufferMemoryInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkBindBufferMemoryInfo*" : "VkBindBufferMemoryInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO: + dump_VkBindImageMemoryInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkBindImageMemoryInfo*" : "VkBindImageMemoryInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: + dump_VkMemoryDedicatedRequirements(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryDedicatedRequirements*" : "VkMemoryDedicatedRequirements"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: + dump_VkMemoryDedicatedAllocateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryDedicatedAllocateInfo*" : "VkMemoryDedicatedAllocateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO: + dump_VkMemoryAllocateFlagsInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryAllocateFlagsInfo*" : "VkMemoryAllocateFlagsInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: + dump_VkDeviceGroupCommandBufferBeginInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceGroupCommandBufferBeginInfo*" : "VkDeviceGroupCommandBufferBeginInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO: + dump_VkDeviceGroupSubmitInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceGroupSubmitInfo*" : "VkDeviceGroupSubmitInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO: + dump_VkDeviceGroupBindSparseInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceGroupBindSparseInfo*" : "VkDeviceGroupBindSparseInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: + dump_VkBindBufferMemoryDeviceGroupInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkBindBufferMemoryDeviceGroupInfo*" : "VkBindBufferMemoryDeviceGroupInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: + dump_VkBindImageMemoryDeviceGroupInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkBindImageMemoryDeviceGroupInfo*" : "VkBindImageMemoryDeviceGroupInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES: + dump_VkPhysicalDeviceGroupProperties(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceGroupProperties*" : "VkPhysicalDeviceGroupProperties"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO: + dump_VkDeviceGroupDeviceCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceGroupDeviceCreateInfo*" : "VkDeviceGroupDeviceCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2: + dump_VkBufferMemoryRequirementsInfo2(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkBufferMemoryRequirementsInfo2*" : "VkBufferMemoryRequirementsInfo2"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2: + dump_VkImageMemoryRequirementsInfo2(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImageMemoryRequirementsInfo2*" : "VkImageMemoryRequirementsInfo2"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2: + dump_VkImageSparseMemoryRequirementsInfo2(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImageSparseMemoryRequirementsInfo2*" : "VkImageSparseMemoryRequirementsInfo2"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2: + dump_VkMemoryRequirements2(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryRequirements2*" : "VkMemoryRequirements2"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2: + dump_VkSparseImageMemoryRequirements2(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSparseImageMemoryRequirements2*" : "VkSparseImageMemoryRequirements2"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: + dump_VkPhysicalDeviceFeatures2(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFeatures2*" : "VkPhysicalDeviceFeatures2"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2: + dump_VkPhysicalDeviceProperties2(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceProperties2*" : "VkPhysicalDeviceProperties2"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2: + dump_VkFormatProperties2(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkFormatProperties2*" : "VkFormatProperties2"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2: + dump_VkImageFormatProperties2(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImageFormatProperties2*" : "VkImageFormatProperties2"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2: + dump_VkPhysicalDeviceImageFormatInfo2(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceImageFormatInfo2*" : "VkPhysicalDeviceImageFormatInfo2"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2: + dump_VkQueueFamilyProperties2(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkQueueFamilyProperties2*" : "VkQueueFamilyProperties2"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2: + dump_VkPhysicalDeviceMemoryProperties2(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMemoryProperties2*" : "VkPhysicalDeviceMemoryProperties2"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2: + dump_VkSparseImageFormatProperties2(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSparseImageFormatProperties2*" : "VkSparseImageFormatProperties2"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2: + dump_VkPhysicalDeviceSparseImageFormatInfo2(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceSparseImageFormatInfo2*" : "VkPhysicalDeviceSparseImageFormatInfo2"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO: + dump_VkImageViewUsageCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImageViewUsageCreateInfo*" : "VkImageViewUsageCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: + dump_VkPhysicalDeviceProtectedMemoryFeatures(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceProtectedMemoryFeatures*" : "VkPhysicalDeviceProtectedMemoryFeatures"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: + dump_VkPhysicalDeviceProtectedMemoryProperties(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceProtectedMemoryProperties*" : "VkPhysicalDeviceProtectedMemoryProperties"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2: + dump_VkDeviceQueueInfo2(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceQueueInfo2*" : "VkDeviceQueueInfo2"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO: + dump_VkProtectedSubmitInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkProtectedSubmitInfo*" : "VkProtectedSubmitInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO: + dump_VkBindImagePlaneMemoryInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkBindImagePlaneMemoryInfo*" : "VkBindImagePlaneMemoryInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: + dump_VkImagePlaneMemoryRequirementsInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImagePlaneMemoryRequirementsInfo*" : "VkImagePlaneMemoryRequirementsInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: + dump_VkPhysicalDeviceExternalImageFormatInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceExternalImageFormatInfo*" : "VkPhysicalDeviceExternalImageFormatInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES: + dump_VkExternalImageFormatProperties(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkExternalImageFormatProperties*" : "VkExternalImageFormatProperties"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO: + dump_VkPhysicalDeviceExternalBufferInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceExternalBufferInfo*" : "VkPhysicalDeviceExternalBufferInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES: + dump_VkExternalBufferProperties(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkExternalBufferProperties*" : "VkExternalBufferProperties"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: + dump_VkPhysicalDeviceIDProperties(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceIDProperties*" : "VkPhysicalDeviceIDProperties"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: + dump_VkExternalMemoryImageCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkExternalMemoryImageCreateInfo*" : "VkExternalMemoryImageCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: + dump_VkExternalMemoryBufferCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkExternalMemoryBufferCreateInfo*" : "VkExternalMemoryBufferCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO: + dump_VkExportMemoryAllocateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkExportMemoryAllocateInfo*" : "VkExportMemoryAllocateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO: + dump_VkPhysicalDeviceExternalFenceInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceExternalFenceInfo*" : "VkPhysicalDeviceExternalFenceInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES: + dump_VkExternalFenceProperties(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkExternalFenceProperties*" : "VkExternalFenceProperties"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO: + dump_VkExportFenceCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkExportFenceCreateInfo*" : "VkExportFenceCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO: + dump_VkExportSemaphoreCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkExportSemaphoreCreateInfo*" : "VkExportSemaphoreCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO: + dump_VkPhysicalDeviceExternalSemaphoreInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceExternalSemaphoreInfo*" : "VkPhysicalDeviceExternalSemaphoreInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES: + dump_VkExternalSemaphoreProperties(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkExternalSemaphoreProperties*" : "VkExternalSemaphoreProperties"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: + dump_VkPhysicalDeviceSubgroupProperties(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceSubgroupProperties*" : "VkPhysicalDeviceSubgroupProperties"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: + dump_VkPhysicalDevice16BitStorageFeatures(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevice16BitStorageFeatures*" : "VkPhysicalDevice16BitStorageFeatures"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: + dump_VkPhysicalDeviceVariablePointersFeatures(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVariablePointersFeatures*" : "VkPhysicalDeviceVariablePointersFeatures"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO: + dump_VkDescriptorUpdateTemplateCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDescriptorUpdateTemplateCreateInfo*" : "VkDescriptorUpdateTemplateCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: + dump_VkPhysicalDeviceMaintenance3Properties(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMaintenance3Properties*" : "VkPhysicalDeviceMaintenance3Properties"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT: + dump_VkDescriptorSetLayoutSupport(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDescriptorSetLayoutSupport*" : "VkDescriptorSetLayoutSupport"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO: + dump_VkSamplerYcbcrConversionCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSamplerYcbcrConversionCreateInfo*" : "VkSamplerYcbcrConversionCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: + dump_VkSamplerYcbcrConversionInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSamplerYcbcrConversionInfo*" : "VkSamplerYcbcrConversionInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: + dump_VkPhysicalDeviceSamplerYcbcrConversionFeatures(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceSamplerYcbcrConversionFeatures*" : "VkPhysicalDeviceSamplerYcbcrConversionFeatures"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: + dump_VkSamplerYcbcrConversionImageFormatProperties(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSamplerYcbcrConversionImageFormatProperties*" : "VkSamplerYcbcrConversionImageFormatProperties"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: + dump_VkDeviceGroupRenderPassBeginInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceGroupRenderPassBeginInfo*" : "VkDeviceGroupRenderPassBeginInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: + dump_VkPhysicalDevicePointClippingProperties(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePointClippingProperties*" : "VkPhysicalDevicePointClippingProperties"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: + dump_VkRenderPassInputAttachmentAspectCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderPassInputAttachmentAspectCreateInfo*" : "VkRenderPassInputAttachmentAspectCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: + dump_VkPipelineTessellationDomainOriginStateCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineTessellationDomainOriginStateCreateInfo*" : "VkPipelineTessellationDomainOriginStateCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO: + dump_VkRenderPassMultiviewCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderPassMultiviewCreateInfo*" : "VkRenderPassMultiviewCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: + dump_VkPhysicalDeviceMultiviewFeatures(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMultiviewFeatures*" : "VkPhysicalDeviceMultiviewFeatures"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: + dump_VkPhysicalDeviceMultiviewProperties(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMultiviewProperties*" : "VkPhysicalDeviceMultiviewProperties"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: + dump_VkPhysicalDeviceShaderDrawParametersFeatures(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderDrawParametersFeatures*" : "VkPhysicalDeviceShaderDrawParametersFeatures"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + dump_VkPhysicalDeviceVulkan11Features(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVulkan11Features*" : "VkPhysicalDeviceVulkan11Features"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: + dump_VkPhysicalDeviceVulkan11Properties(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVulkan11Properties*" : "VkPhysicalDeviceVulkan11Properties"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + dump_VkPhysicalDeviceVulkan12Features(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVulkan12Features*" : "VkPhysicalDeviceVulkan12Features"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: + dump_VkPhysicalDeviceVulkan12Properties(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVulkan12Properties*" : "VkPhysicalDeviceVulkan12Properties"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: + dump_VkImageFormatListCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImageFormatListCreateInfo*" : "VkImageFormatListCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES: + dump_VkPhysicalDeviceDriverProperties(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDriverProperties*" : "VkPhysicalDeviceDriverProperties"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: + dump_VkPhysicalDeviceVulkanMemoryModelFeatures(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVulkanMemoryModelFeatures*" : "VkPhysicalDeviceVulkanMemoryModelFeatures"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: + dump_VkPhysicalDeviceHostQueryResetFeatures(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceHostQueryResetFeatures*" : "VkPhysicalDeviceHostQueryResetFeatures"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: + dump_VkPhysicalDeviceTimelineSemaphoreFeatures(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceTimelineSemaphoreFeatures*" : "VkPhysicalDeviceTimelineSemaphoreFeatures"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: + dump_VkPhysicalDeviceTimelineSemaphoreProperties(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceTimelineSemaphoreProperties*" : "VkPhysicalDeviceTimelineSemaphoreProperties"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO: + dump_VkSemaphoreTypeCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSemaphoreTypeCreateInfo*" : "VkSemaphoreTypeCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO: + dump_VkTimelineSemaphoreSubmitInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkTimelineSemaphoreSubmitInfo*" : "VkTimelineSemaphoreSubmitInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO: + dump_VkSemaphoreWaitInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSemaphoreWaitInfo*" : "VkSemaphoreWaitInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO: + dump_VkSemaphoreSignalInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSemaphoreSignalInfo*" : "VkSemaphoreSignalInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: + dump_VkPhysicalDeviceBufferDeviceAddressFeatures(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceBufferDeviceAddressFeatures*" : "VkPhysicalDeviceBufferDeviceAddressFeatures"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO: + dump_VkBufferDeviceAddressInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkBufferDeviceAddressInfo*" : "VkBufferDeviceAddressInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: + dump_VkBufferOpaqueCaptureAddressCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkBufferOpaqueCaptureAddressCreateInfo*" : "VkBufferOpaqueCaptureAddressCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO: + dump_VkMemoryOpaqueCaptureAddressAllocateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryOpaqueCaptureAddressAllocateInfo*" : "VkMemoryOpaqueCaptureAddressAllocateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO: + dump_VkDeviceMemoryOpaqueCaptureAddressInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceMemoryOpaqueCaptureAddressInfo*" : "VkDeviceMemoryOpaqueCaptureAddressInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: + dump_VkPhysicalDevice8BitStorageFeatures(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevice8BitStorageFeatures*" : "VkPhysicalDevice8BitStorageFeatures"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: + dump_VkPhysicalDeviceShaderAtomicInt64Features(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderAtomicInt64Features*" : "VkPhysicalDeviceShaderAtomicInt64Features"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: + dump_VkPhysicalDeviceShaderFloat16Int8Features(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderFloat16Int8Features*" : "VkPhysicalDeviceShaderFloat16Int8Features"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: + dump_VkPhysicalDeviceFloatControlsProperties(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFloatControlsProperties*" : "VkPhysicalDeviceFloatControlsProperties"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO: + dump_VkDescriptorSetLayoutBindingFlagsCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDescriptorSetLayoutBindingFlagsCreateInfo*" : "VkDescriptorSetLayoutBindingFlagsCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: + dump_VkPhysicalDeviceDescriptorIndexingFeatures(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDescriptorIndexingFeatures*" : "VkPhysicalDeviceDescriptorIndexingFeatures"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: + dump_VkPhysicalDeviceDescriptorIndexingProperties(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDescriptorIndexingProperties*" : "VkPhysicalDeviceDescriptorIndexingProperties"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO: + dump_VkDescriptorSetVariableDescriptorCountAllocateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDescriptorSetVariableDescriptorCountAllocateInfo*" : "VkDescriptorSetVariableDescriptorCountAllocateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT: + dump_VkDescriptorSetVariableDescriptorCountLayoutSupport(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDescriptorSetVariableDescriptorCountLayoutSupport*" : "VkDescriptorSetVariableDescriptorCountLayoutSupport"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: + dump_VkPhysicalDeviceScalarBlockLayoutFeatures(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceScalarBlockLayoutFeatures*" : "VkPhysicalDeviceScalarBlockLayoutFeatures"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO: + dump_VkSamplerReductionModeCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSamplerReductionModeCreateInfo*" : "VkSamplerReductionModeCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: + dump_VkPhysicalDeviceSamplerFilterMinmaxProperties(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceSamplerFilterMinmaxProperties*" : "VkPhysicalDeviceSamplerFilterMinmaxProperties"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: + dump_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceUniformBufferStandardLayoutFeatures*" : "VkPhysicalDeviceUniformBufferStandardLayoutFeatures"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: + dump_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*" : "VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2: + dump_VkAttachmentDescription2(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkAttachmentDescription2*" : "VkAttachmentDescription2"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2: + dump_VkAttachmentReference2(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkAttachmentReference2*" : "VkAttachmentReference2"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2: + dump_VkSubpassDescription2(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSubpassDescription2*" : "VkSubpassDescription2"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2: + dump_VkSubpassDependency2(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSubpassDependency2*" : "VkSubpassDependency2"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2: + dump_VkRenderPassCreateInfo2(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderPassCreateInfo2*" : "VkRenderPassCreateInfo2"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO: + dump_VkSubpassBeginInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSubpassBeginInfo*" : "VkSubpassBeginInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SUBPASS_END_INFO: + dump_VkSubpassEndInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSubpassEndInfo*" : "VkSubpassEndInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE: + dump_VkSubpassDescriptionDepthStencilResolve(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSubpassDescriptionDepthStencilResolve*" : "VkSubpassDescriptionDepthStencilResolve"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: + dump_VkPhysicalDeviceDepthStencilResolveProperties(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDepthStencilResolveProperties*" : "VkPhysicalDeviceDepthStencilResolveProperties"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: + dump_VkImageStencilUsageCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImageStencilUsageCreateInfo*" : "VkImageStencilUsageCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: + dump_VkPhysicalDeviceImagelessFramebufferFeatures(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceImagelessFramebufferFeatures*" : "VkPhysicalDeviceImagelessFramebufferFeatures"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO: + dump_VkFramebufferAttachmentImageInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkFramebufferAttachmentImageInfo*" : "VkFramebufferAttachmentImageInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO: + dump_VkFramebufferAttachmentsCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkFramebufferAttachmentsCreateInfo*" : "VkFramebufferAttachmentsCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO: + dump_VkRenderPassAttachmentBeginInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderPassAttachmentBeginInfo*" : "VkRenderPassAttachmentBeginInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: + dump_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*" : "VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT: + dump_VkAttachmentReferenceStencilLayout(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkAttachmentReferenceStencilLayout*" : "VkAttachmentReferenceStencilLayout"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT: + dump_VkAttachmentDescriptionStencilLayout(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkAttachmentDescriptionStencilLayout*" : "VkAttachmentDescriptionStencilLayout"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: + dump_VkPhysicalDeviceVulkan13Features(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVulkan13Features*" : "VkPhysicalDeviceVulkan13Features"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: + dump_VkPhysicalDeviceVulkan13Properties(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVulkan13Properties*" : "VkPhysicalDeviceVulkan13Properties"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES: + dump_VkPhysicalDeviceToolProperties(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceToolProperties*" : "VkPhysicalDeviceToolProperties"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: + dump_VkPhysicalDevicePrivateDataFeatures(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePrivateDataFeatures*" : "VkPhysicalDevicePrivateDataFeatures"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO: + dump_VkDevicePrivateDataCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDevicePrivateDataCreateInfo*" : "VkDevicePrivateDataCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO: + dump_VkPrivateDataSlotCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPrivateDataSlotCreateInfo*" : "VkPrivateDataSlotCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2: + dump_VkMemoryBarrier2(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryBarrier2*" : "VkMemoryBarrier2"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2: + dump_VkBufferMemoryBarrier2(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkBufferMemoryBarrier2*" : "VkBufferMemoryBarrier2"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2: + dump_VkImageMemoryBarrier2(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImageMemoryBarrier2*" : "VkImageMemoryBarrier2"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DEPENDENCY_INFO: + dump_VkDependencyInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDependencyInfo*" : "VkDependencyInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO: + dump_VkSemaphoreSubmitInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSemaphoreSubmitInfo*" : "VkSemaphoreSubmitInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO: + dump_VkCommandBufferSubmitInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCommandBufferSubmitInfo*" : "VkCommandBufferSubmitInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SUBMIT_INFO_2: + dump_VkSubmitInfo2(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSubmitInfo2*" : "VkSubmitInfo2"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: + dump_VkPhysicalDeviceSynchronization2Features(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceSynchronization2Features*" : "VkPhysicalDeviceSynchronization2Features"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_BUFFER_COPY_2: + dump_VkBufferCopy2(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkBufferCopy2*" : "VkBufferCopy2"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2: + dump_VkCopyBufferInfo2(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCopyBufferInfo2*" : "VkCopyBufferInfo2"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMAGE_COPY_2: + dump_VkImageCopy2(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImageCopy2*" : "VkImageCopy2"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2: + dump_VkCopyImageInfo2(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCopyImageInfo2*" : "VkCopyImageInfo2"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2: + dump_VkBufferImageCopy2(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkBufferImageCopy2*" : "VkBufferImageCopy2"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2: + dump_VkCopyBufferToImageInfo2(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCopyBufferToImageInfo2*" : "VkCopyBufferToImageInfo2"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2: + dump_VkCopyImageToBufferInfo2(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCopyImageToBufferInfo2*" : "VkCopyImageToBufferInfo2"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: + dump_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceTextureCompressionASTCHDRFeatures*" : "VkPhysicalDeviceTextureCompressionASTCHDRFeatures"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3: + dump_VkFormatProperties3(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkFormatProperties3*" : "VkFormatProperties3"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: + dump_VkPhysicalDeviceMaintenance4Features(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMaintenance4Features*" : "VkPhysicalDeviceMaintenance4Features"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: + dump_VkPhysicalDeviceMaintenance4Properties(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMaintenance4Properties*" : "VkPhysicalDeviceMaintenance4Properties"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS: + dump_VkDeviceBufferMemoryRequirements(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceBufferMemoryRequirements*" : "VkDeviceBufferMemoryRequirements"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS: + dump_VkDeviceImageMemoryRequirements(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceImageMemoryRequirements*" : "VkDeviceImageMemoryRequirements"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: + dump_VkPipelineCreationFeedbackCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineCreationFeedbackCreateInfo*" : "VkPipelineCreationFeedbackCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: + dump_VkPhysicalDeviceShaderTerminateInvocationFeatures(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderTerminateInvocationFeatures*" : "VkPhysicalDeviceShaderTerminateInvocationFeatures"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: + dump_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures*" : "VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: + dump_VkPhysicalDevicePipelineCreationCacheControlFeatures(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePipelineCreationCacheControlFeatures*" : "VkPhysicalDevicePipelineCreationCacheControlFeatures"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: + dump_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures*" : "VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: + dump_VkPhysicalDeviceImageRobustnessFeatures(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceImageRobustnessFeatures*" : "VkPhysicalDeviceImageRobustnessFeatures"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: + dump_VkPhysicalDeviceSubgroupSizeControlFeatures(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceSubgroupSizeControlFeatures*" : "VkPhysicalDeviceSubgroupSizeControlFeatures"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: + dump_VkPhysicalDeviceSubgroupSizeControlProperties(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceSubgroupSizeControlProperties*" : "VkPhysicalDeviceSubgroupSizeControlProperties"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: + dump_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineShaderStageRequiredSubgroupSizeCreateInfo*" : "VkPipelineShaderStageRequiredSubgroupSizeCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: + dump_VkPhysicalDeviceInlineUniformBlockFeatures(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceInlineUniformBlockFeatures*" : "VkPhysicalDeviceInlineUniformBlockFeatures"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: + dump_VkPhysicalDeviceInlineUniformBlockProperties(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceInlineUniformBlockProperties*" : "VkPhysicalDeviceInlineUniformBlockProperties"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK: + dump_VkWriteDescriptorSetInlineUniformBlock(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkWriteDescriptorSetInlineUniformBlock*" : "VkWriteDescriptorSetInlineUniformBlock"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO: + dump_VkDescriptorPoolInlineUniformBlockCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDescriptorPoolInlineUniformBlockCreateInfo*" : "VkDescriptorPoolInlineUniformBlockCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: + dump_VkPhysicalDeviceShaderIntegerDotProductFeatures(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderIntegerDotProductFeatures*" : "VkPhysicalDeviceShaderIntegerDotProductFeatures"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: + dump_VkPhysicalDeviceShaderIntegerDotProductProperties(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderIntegerDotProductProperties*" : "VkPhysicalDeviceShaderIntegerDotProductProperties"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: + dump_VkPhysicalDeviceTexelBufferAlignmentProperties(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceTexelBufferAlignmentProperties*" : "VkPhysicalDeviceTexelBufferAlignmentProperties"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMAGE_BLIT_2: + dump_VkImageBlit2(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImageBlit2*" : "VkImageBlit2"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2: + dump_VkBlitImageInfo2(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkBlitImageInfo2*" : "VkBlitImageInfo2"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2: + dump_VkImageResolve2(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImageResolve2*" : "VkImageResolve2"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2: + dump_VkResolveImageInfo2(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkResolveImageInfo2*" : "VkResolveImageInfo2"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO: + dump_VkRenderingAttachmentInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderingAttachmentInfo*" : "VkRenderingAttachmentInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_RENDERING_INFO: + dump_VkRenderingInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderingInfo*" : "VkRenderingInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO: + dump_VkPipelineRenderingCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineRenderingCreateInfo*" : "VkPipelineRenderingCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: + dump_VkPhysicalDeviceDynamicRenderingFeatures(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDynamicRenderingFeatures*" : "VkPhysicalDeviceDynamicRenderingFeatures"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO: + dump_VkCommandBufferInheritanceRenderingInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCommandBufferInheritanceRenderingInfo*" : "VkCommandBufferInheritanceRenderingInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES: + dump_VkPhysicalDeviceVulkan14Features(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVulkan14Features*" : "VkPhysicalDeviceVulkan14Features"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES: + dump_VkPhysicalDeviceVulkan14Properties(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVulkan14Properties*" : "VkPhysicalDeviceVulkan14Properties"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO: + dump_VkDeviceQueueGlobalPriorityCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceQueueGlobalPriorityCreateInfo*" : "VkDeviceQueueGlobalPriorityCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES: + dump_VkPhysicalDeviceGlobalPriorityQueryFeatures(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceGlobalPriorityQueryFeatures*" : "VkPhysicalDeviceGlobalPriorityQueryFeatures"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES: + dump_VkQueueFamilyGlobalPriorityProperties(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkQueueFamilyGlobalPriorityProperties*" : "VkQueueFamilyGlobalPriorityProperties"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES: + dump_VkPhysicalDeviceIndexTypeUint8Features(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceIndexTypeUint8Features*" : "VkPhysicalDeviceIndexTypeUint8Features"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_MEMORY_MAP_INFO: + dump_VkMemoryMapInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryMapInfo*" : "VkMemoryMapInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO: + dump_VkMemoryUnmapInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryUnmapInfo*" : "VkMemoryUnmapInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES: + dump_VkPhysicalDeviceMaintenance5Features(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMaintenance5Features*" : "VkPhysicalDeviceMaintenance5Features"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES: + dump_VkPhysicalDeviceMaintenance5Properties(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMaintenance5Properties*" : "VkPhysicalDeviceMaintenance5Properties"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2: + dump_VkImageSubresource2(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImageSubresource2*" : "VkImageSubresource2"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO: + dump_VkDeviceImageSubresourceInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceImageSubresourceInfo*" : "VkDeviceImageSubresourceInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2: + dump_VkSubresourceLayout2(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSubresourceLayout2*" : "VkSubresourceLayout2"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO: + dump_VkBufferUsageFlags2CreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkBufferUsageFlags2CreateInfo*" : "VkBufferUsageFlags2CreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES: + dump_VkPhysicalDeviceMaintenance6Features(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMaintenance6Features*" : "VkPhysicalDeviceMaintenance6Features"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES: + dump_VkPhysicalDeviceMaintenance6Properties(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMaintenance6Properties*" : "VkPhysicalDeviceMaintenance6Properties"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS: + dump_VkBindMemoryStatus(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkBindMemoryStatus*" : "VkBindMemoryStatus"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES: + dump_VkPhysicalDeviceHostImageCopyFeatures(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceHostImageCopyFeatures*" : "VkPhysicalDeviceHostImageCopyFeatures"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES: + dump_VkPhysicalDeviceHostImageCopyProperties(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceHostImageCopyProperties*" : "VkPhysicalDeviceHostImageCopyProperties"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY: + dump_VkMemoryToImageCopy(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryToImageCopy*" : "VkMemoryToImageCopy"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY: + dump_VkImageToMemoryCopy(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImageToMemoryCopy*" : "VkImageToMemoryCopy"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO: + dump_VkCopyMemoryToImageInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCopyMemoryToImageInfo*" : "VkCopyMemoryToImageInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO: + dump_VkCopyImageToMemoryInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCopyImageToMemoryInfo*" : "VkCopyImageToMemoryInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO: + dump_VkCopyImageToImageInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCopyImageToImageInfo*" : "VkCopyImageToImageInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO: + dump_VkHostImageLayoutTransitionInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkHostImageLayoutTransitionInfo*" : "VkHostImageLayoutTransitionInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE: + dump_VkSubresourceHostMemcpySize(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSubresourceHostMemcpySize*" : "VkSubresourceHostMemcpySize"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY: + dump_VkHostImageCopyDevicePerformanceQuery(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkHostImageCopyDevicePerformanceQuery*" : "VkHostImageCopyDevicePerformanceQuery"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES: + dump_VkPhysicalDeviceShaderSubgroupRotateFeatures(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderSubgroupRotateFeatures*" : "VkPhysicalDeviceShaderSubgroupRotateFeatures"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES: + dump_VkPhysicalDeviceShaderFloatControls2Features(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderFloatControls2Features*" : "VkPhysicalDeviceShaderFloatControls2Features"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES: + dump_VkPhysicalDeviceShaderExpectAssumeFeatures(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderExpectAssumeFeatures*" : "VkPhysicalDeviceShaderExpectAssumeFeatures"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO: + dump_VkPipelineCreateFlags2CreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineCreateFlags2CreateInfo*" : "VkPipelineCreateFlags2CreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES: + dump_VkPhysicalDevicePushDescriptorProperties(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePushDescriptorProperties*" : "VkPhysicalDevicePushDescriptorProperties"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO: + dump_VkBindDescriptorSetsInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkBindDescriptorSetsInfo*" : "VkBindDescriptorSetsInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO: + dump_VkPushConstantsInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPushConstantsInfo*" : "VkPushConstantsInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO: + dump_VkPushDescriptorSetInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPushDescriptorSetInfo*" : "VkPushDescriptorSetInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO: + dump_VkPushDescriptorSetWithTemplateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPushDescriptorSetWithTemplateInfo*" : "VkPushDescriptorSetWithTemplateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES: + dump_VkPhysicalDevicePipelineProtectedAccessFeatures(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePipelineProtectedAccessFeatures*" : "VkPhysicalDevicePipelineProtectedAccessFeatures"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES: + dump_VkPhysicalDevicePipelineRobustnessFeatures(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePipelineRobustnessFeatures*" : "VkPhysicalDevicePipelineRobustnessFeatures"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES: + dump_VkPhysicalDevicePipelineRobustnessProperties(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePipelineRobustnessProperties*" : "VkPhysicalDevicePipelineRobustnessProperties"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO: + dump_VkPipelineRobustnessCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineRobustnessCreateInfo*" : "VkPipelineRobustnessCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES: + dump_VkPhysicalDeviceLineRasterizationFeatures(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceLineRasterizationFeatures*" : "VkPhysicalDeviceLineRasterizationFeatures"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES: + dump_VkPhysicalDeviceLineRasterizationProperties(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceLineRasterizationProperties*" : "VkPhysicalDeviceLineRasterizationProperties"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO: + dump_VkPipelineRasterizationLineStateCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineRasterizationLineStateCreateInfo*" : "VkPipelineRasterizationLineStateCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES: + dump_VkPhysicalDeviceVertexAttributeDivisorProperties(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVertexAttributeDivisorProperties*" : "VkPhysicalDeviceVertexAttributeDivisorProperties"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO: + dump_VkPipelineVertexInputDivisorStateCreateInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineVertexInputDivisorStateCreateInfo*" : "VkPipelineVertexInputDivisorStateCreateInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES: + dump_VkPhysicalDeviceVertexAttributeDivisorFeatures(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVertexAttributeDivisorFeatures*" : "VkPhysicalDeviceVertexAttributeDivisorFeatures"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_RENDERING_AREA_INFO: + dump_VkRenderingAreaInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderingAreaInfo*" : "VkRenderingAreaInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES: + dump_VkPhysicalDeviceDynamicRenderingLocalReadFeatures(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDynamicRenderingLocalReadFeatures*" : "VkPhysicalDeviceDynamicRenderingLocalReadFeatures"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO: + dump_VkRenderingAttachmentLocationInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderingAttachmentLocationInfo*" : "VkRenderingAttachmentLocationInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO: + dump_VkRenderingInputAttachmentIndexInfo(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderingInputAttachmentIndexInfo*" : "VkRenderingInputAttachmentIndexInfo"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR: + dump_VkSwapchainCreateInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSwapchainCreateInfoKHR*" : "VkSwapchainCreateInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PRESENT_INFO_KHR: + dump_VkPresentInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPresentInfoKHR*" : "VkPresentInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: + dump_VkImageSwapchainCreateInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImageSwapchainCreateInfoKHR*" : "VkImageSwapchainCreateInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR: + dump_VkBindImageMemorySwapchainInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkBindImageMemorySwapchainInfoKHR*" : "VkBindImageMemorySwapchainInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR: + dump_VkAcquireNextImageInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkAcquireNextImageInfoKHR*" : "VkAcquireNextImageInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR: + dump_VkDeviceGroupPresentCapabilitiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceGroupPresentCapabilitiesKHR*" : "VkDeviceGroupPresentCapabilitiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR: + dump_VkDeviceGroupPresentInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceGroupPresentInfoKHR*" : "VkDeviceGroupPresentInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR: + dump_VkDeviceGroupSwapchainCreateInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceGroupSwapchainCreateInfoKHR*" : "VkDeviceGroupSwapchainCreateInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR: + dump_VkDisplayModeCreateInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDisplayModeCreateInfoKHR*" : "VkDisplayModeCreateInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR: + dump_VkDisplaySurfaceCreateInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDisplaySurfaceCreateInfoKHR*" : "VkDisplaySurfaceCreateInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR: + dump_VkDisplayPresentInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDisplayPresentInfoKHR*" : "VkDisplayPresentInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; +#if defined(VK_USE_PLATFORM_XLIB_KHR) + + case VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR: + dump_VkXlibSurfaceCreateInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkXlibSurfaceCreateInfoKHR*" : "VkXlibSurfaceCreateInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; +#endif // VK_USE_PLATFORM_XLIB_KHR +#if defined(VK_USE_PLATFORM_XCB_KHR) + + case VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR: + dump_VkXcbSurfaceCreateInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkXcbSurfaceCreateInfoKHR*" : "VkXcbSurfaceCreateInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; +#endif // VK_USE_PLATFORM_XCB_KHR +#if defined(VK_USE_PLATFORM_WAYLAND_KHR) + + case VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR: + dump_VkWaylandSurfaceCreateInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkWaylandSurfaceCreateInfoKHR*" : "VkWaylandSurfaceCreateInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; +#endif // VK_USE_PLATFORM_WAYLAND_KHR +#if defined(VK_USE_PLATFORM_ANDROID_KHR) + + case VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR: + dump_VkAndroidSurfaceCreateInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkAndroidSurfaceCreateInfoKHR*" : "VkAndroidSurfaceCreateInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; +#endif // VK_USE_PLATFORM_ANDROID_KHR +#if defined(VK_USE_PLATFORM_WIN32_KHR) + + case VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR: + dump_VkWin32SurfaceCreateInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkWin32SurfaceCreateInfoKHR*" : "VkWin32SurfaceCreateInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; +#endif // VK_USE_PLATFORM_WIN32_KHR + + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR: + dump_VkQueueFamilyQueryResultStatusPropertiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkQueueFamilyQueryResultStatusPropertiesKHR*" : "VkQueueFamilyQueryResultStatusPropertiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR: + dump_VkQueueFamilyVideoPropertiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkQueueFamilyVideoPropertiesKHR*" : "VkQueueFamilyVideoPropertiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR: + dump_VkVideoProfileInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoProfileInfoKHR*" : "VkVideoProfileInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR: + dump_VkVideoProfileListInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoProfileListInfoKHR*" : "VkVideoProfileListInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR: + dump_VkVideoCapabilitiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoCapabilitiesKHR*" : "VkVideoCapabilitiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR: + dump_VkPhysicalDeviceVideoFormatInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVideoFormatInfoKHR*" : "VkPhysicalDeviceVideoFormatInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR: + dump_VkVideoFormatPropertiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoFormatPropertiesKHR*" : "VkVideoFormatPropertiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR: + dump_VkVideoPictureResourceInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoPictureResourceInfoKHR*" : "VkVideoPictureResourceInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR: + dump_VkVideoReferenceSlotInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoReferenceSlotInfoKHR*" : "VkVideoReferenceSlotInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR: + dump_VkVideoSessionMemoryRequirementsKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoSessionMemoryRequirementsKHR*" : "VkVideoSessionMemoryRequirementsKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR: + dump_VkBindVideoSessionMemoryInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkBindVideoSessionMemoryInfoKHR*" : "VkBindVideoSessionMemoryInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR: + dump_VkVideoSessionCreateInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoSessionCreateInfoKHR*" : "VkVideoSessionCreateInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR: + dump_VkVideoSessionParametersCreateInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoSessionParametersCreateInfoKHR*" : "VkVideoSessionParametersCreateInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR: + dump_VkVideoSessionParametersUpdateInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoSessionParametersUpdateInfoKHR*" : "VkVideoSessionParametersUpdateInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR: + dump_VkVideoBeginCodingInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoBeginCodingInfoKHR*" : "VkVideoBeginCodingInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR: + dump_VkVideoEndCodingInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEndCodingInfoKHR*" : "VkVideoEndCodingInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR: + dump_VkVideoCodingControlInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoCodingControlInfoKHR*" : "VkVideoCodingControlInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR: + dump_VkVideoDecodeCapabilitiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeCapabilitiesKHR*" : "VkVideoDecodeCapabilitiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR: + dump_VkVideoDecodeUsageInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeUsageInfoKHR*" : "VkVideoDecodeUsageInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR: + dump_VkVideoDecodeInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeInfoKHR*" : "VkVideoDecodeInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR: + dump_VkVideoEncodeH264CapabilitiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH264CapabilitiesKHR*" : "VkVideoEncodeH264CapabilitiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR: + dump_VkVideoEncodeH264QualityLevelPropertiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH264QualityLevelPropertiesKHR*" : "VkVideoEncodeH264QualityLevelPropertiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR: + dump_VkVideoEncodeH264SessionCreateInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH264SessionCreateInfoKHR*" : "VkVideoEncodeH264SessionCreateInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: + dump_VkVideoEncodeH264SessionParametersAddInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH264SessionParametersAddInfoKHR*" : "VkVideoEncodeH264SessionParametersAddInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: + dump_VkVideoEncodeH264SessionParametersCreateInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH264SessionParametersCreateInfoKHR*" : "VkVideoEncodeH264SessionParametersCreateInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR: + dump_VkVideoEncodeH264SessionParametersGetInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH264SessionParametersGetInfoKHR*" : "VkVideoEncodeH264SessionParametersGetInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: + dump_VkVideoEncodeH264SessionParametersFeedbackInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH264SessionParametersFeedbackInfoKHR*" : "VkVideoEncodeH264SessionParametersFeedbackInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR: + dump_VkVideoEncodeH264NaluSliceInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH264NaluSliceInfoKHR*" : "VkVideoEncodeH264NaluSliceInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR: + dump_VkVideoEncodeH264PictureInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH264PictureInfoKHR*" : "VkVideoEncodeH264PictureInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR: + dump_VkVideoEncodeH264DpbSlotInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH264DpbSlotInfoKHR*" : "VkVideoEncodeH264DpbSlotInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR: + dump_VkVideoEncodeH264ProfileInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH264ProfileInfoKHR*" : "VkVideoEncodeH264ProfileInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR: + dump_VkVideoEncodeH264RateControlInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH264RateControlInfoKHR*" : "VkVideoEncodeH264RateControlInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR: + dump_VkVideoEncodeH264RateControlLayerInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH264RateControlLayerInfoKHR*" : "VkVideoEncodeH264RateControlLayerInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR: + dump_VkVideoEncodeH264GopRemainingFrameInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH264GopRemainingFrameInfoKHR*" : "VkVideoEncodeH264GopRemainingFrameInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR: + dump_VkVideoEncodeH265CapabilitiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH265CapabilitiesKHR*" : "VkVideoEncodeH265CapabilitiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR: + dump_VkVideoEncodeH265SessionCreateInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH265SessionCreateInfoKHR*" : "VkVideoEncodeH265SessionCreateInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR: + dump_VkVideoEncodeH265QualityLevelPropertiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH265QualityLevelPropertiesKHR*" : "VkVideoEncodeH265QualityLevelPropertiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: + dump_VkVideoEncodeH265SessionParametersAddInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH265SessionParametersAddInfoKHR*" : "VkVideoEncodeH265SessionParametersAddInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: + dump_VkVideoEncodeH265SessionParametersCreateInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH265SessionParametersCreateInfoKHR*" : "VkVideoEncodeH265SessionParametersCreateInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR: + dump_VkVideoEncodeH265SessionParametersGetInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH265SessionParametersGetInfoKHR*" : "VkVideoEncodeH265SessionParametersGetInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: + dump_VkVideoEncodeH265SessionParametersFeedbackInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH265SessionParametersFeedbackInfoKHR*" : "VkVideoEncodeH265SessionParametersFeedbackInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR: + dump_VkVideoEncodeH265NaluSliceSegmentInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH265NaluSliceSegmentInfoKHR*" : "VkVideoEncodeH265NaluSliceSegmentInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR: + dump_VkVideoEncodeH265PictureInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH265PictureInfoKHR*" : "VkVideoEncodeH265PictureInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR: + dump_VkVideoEncodeH265DpbSlotInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH265DpbSlotInfoKHR*" : "VkVideoEncodeH265DpbSlotInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR: + dump_VkVideoEncodeH265ProfileInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH265ProfileInfoKHR*" : "VkVideoEncodeH265ProfileInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR: + dump_VkVideoEncodeH265RateControlInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH265RateControlInfoKHR*" : "VkVideoEncodeH265RateControlInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR: + dump_VkVideoEncodeH265RateControlLayerInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH265RateControlLayerInfoKHR*" : "VkVideoEncodeH265RateControlLayerInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR: + dump_VkVideoEncodeH265GopRemainingFrameInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH265GopRemainingFrameInfoKHR*" : "VkVideoEncodeH265GopRemainingFrameInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR: + dump_VkVideoDecodeH264ProfileInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeH264ProfileInfoKHR*" : "VkVideoDecodeH264ProfileInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR: + dump_VkVideoDecodeH264CapabilitiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeH264CapabilitiesKHR*" : "VkVideoDecodeH264CapabilitiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: + dump_VkVideoDecodeH264SessionParametersAddInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeH264SessionParametersAddInfoKHR*" : "VkVideoDecodeH264SessionParametersAddInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: + dump_VkVideoDecodeH264SessionParametersCreateInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeH264SessionParametersCreateInfoKHR*" : "VkVideoDecodeH264SessionParametersCreateInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR: + dump_VkVideoDecodeH264PictureInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeH264PictureInfoKHR*" : "VkVideoDecodeH264PictureInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR: + dump_VkVideoDecodeH264DpbSlotInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeH264DpbSlotInfoKHR*" : "VkVideoDecodeH264DpbSlotInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; +#if defined(VK_USE_PLATFORM_WIN32_KHR) + + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: + dump_VkImportMemoryWin32HandleInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImportMemoryWin32HandleInfoKHR*" : "VkImportMemoryWin32HandleInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR: + dump_VkExportMemoryWin32HandleInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkExportMemoryWin32HandleInfoKHR*" : "VkExportMemoryWin32HandleInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR: + dump_VkMemoryWin32HandlePropertiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryWin32HandlePropertiesKHR*" : "VkMemoryWin32HandlePropertiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR: + dump_VkMemoryGetWin32HandleInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryGetWin32HandleInfoKHR*" : "VkMemoryGetWin32HandleInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; +#endif // VK_USE_PLATFORM_WIN32_KHR + + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR: + dump_VkImportMemoryFdInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImportMemoryFdInfoKHR*" : "VkImportMemoryFdInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR: + dump_VkMemoryFdPropertiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryFdPropertiesKHR*" : "VkMemoryFdPropertiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR: + dump_VkMemoryGetFdInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryGetFdInfoKHR*" : "VkMemoryGetFdInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; +#if defined(VK_USE_PLATFORM_WIN32_KHR) + + case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR: + dump_VkWin32KeyedMutexAcquireReleaseInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkWin32KeyedMutexAcquireReleaseInfoKHR*" : "VkWin32KeyedMutexAcquireReleaseInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: + dump_VkImportSemaphoreWin32HandleInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImportSemaphoreWin32HandleInfoKHR*" : "VkImportSemaphoreWin32HandleInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: + dump_VkExportSemaphoreWin32HandleInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkExportSemaphoreWin32HandleInfoKHR*" : "VkExportSemaphoreWin32HandleInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR: + dump_VkD3D12FenceSubmitInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkD3D12FenceSubmitInfoKHR*" : "VkD3D12FenceSubmitInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR: + dump_VkSemaphoreGetWin32HandleInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSemaphoreGetWin32HandleInfoKHR*" : "VkSemaphoreGetWin32HandleInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; +#endif // VK_USE_PLATFORM_WIN32_KHR + + case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR: + dump_VkImportSemaphoreFdInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImportSemaphoreFdInfoKHR*" : "VkImportSemaphoreFdInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR: + dump_VkSemaphoreGetFdInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSemaphoreGetFdInfoKHR*" : "VkSemaphoreGetFdInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR: + dump_VkPresentRegionsKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPresentRegionsKHR*" : "VkPresentRegionsKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: + dump_VkSharedPresentSurfaceCapabilitiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSharedPresentSurfaceCapabilitiesKHR*" : "VkSharedPresentSurfaceCapabilitiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; +#if defined(VK_USE_PLATFORM_WIN32_KHR) + + case VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR: + dump_VkImportFenceWin32HandleInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImportFenceWin32HandleInfoKHR*" : "VkImportFenceWin32HandleInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR: + dump_VkExportFenceWin32HandleInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkExportFenceWin32HandleInfoKHR*" : "VkExportFenceWin32HandleInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR: + dump_VkFenceGetWin32HandleInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkFenceGetWin32HandleInfoKHR*" : "VkFenceGetWin32HandleInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; +#endif // VK_USE_PLATFORM_WIN32_KHR + + case VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR: + dump_VkImportFenceFdInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImportFenceFdInfoKHR*" : "VkImportFenceFdInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR: + dump_VkFenceGetFdInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkFenceGetFdInfoKHR*" : "VkFenceGetFdInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: + dump_VkPhysicalDevicePerformanceQueryFeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePerformanceQueryFeaturesKHR*" : "VkPhysicalDevicePerformanceQueryFeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR: + dump_VkPhysicalDevicePerformanceQueryPropertiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePerformanceQueryPropertiesKHR*" : "VkPhysicalDevicePerformanceQueryPropertiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR: + dump_VkPerformanceCounterKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPerformanceCounterKHR*" : "VkPerformanceCounterKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR: + dump_VkPerformanceCounterDescriptionKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPerformanceCounterDescriptionKHR*" : "VkPerformanceCounterDescriptionKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR: + dump_VkQueryPoolPerformanceCreateInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkQueryPoolPerformanceCreateInfoKHR*" : "VkQueryPoolPerformanceCreateInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR: + dump_VkAcquireProfilingLockInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkAcquireProfilingLockInfoKHR*" : "VkAcquireProfilingLockInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR: + dump_VkPerformanceQuerySubmitInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPerformanceQuerySubmitInfoKHR*" : "VkPerformanceQuerySubmitInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR: + dump_VkPhysicalDeviceSurfaceInfo2KHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceSurfaceInfo2KHR*" : "VkPhysicalDeviceSurfaceInfo2KHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR: + dump_VkSurfaceCapabilities2KHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSurfaceCapabilities2KHR*" : "VkSurfaceCapabilities2KHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR: + dump_VkSurfaceFormat2KHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSurfaceFormat2KHR*" : "VkSurfaceFormat2KHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR: + dump_VkDisplayProperties2KHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDisplayProperties2KHR*" : "VkDisplayProperties2KHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR: + dump_VkDisplayPlaneProperties2KHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDisplayPlaneProperties2KHR*" : "VkDisplayPlaneProperties2KHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR: + dump_VkDisplayModeProperties2KHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDisplayModeProperties2KHR*" : "VkDisplayModeProperties2KHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR: + dump_VkDisplayPlaneInfo2KHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDisplayPlaneInfo2KHR*" : "VkDisplayPlaneInfo2KHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR: + dump_VkDisplayPlaneCapabilities2KHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDisplayPlaneCapabilities2KHR*" : "VkDisplayPlaneCapabilities2KHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR: + dump_VkPhysicalDeviceShaderBfloat16FeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderBfloat16FeaturesKHR*" : "VkPhysicalDeviceShaderBfloat16FeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; +#if defined(VK_ENABLE_BETA_EXTENSIONS) + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: + dump_VkPhysicalDevicePortabilitySubsetFeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePortabilitySubsetFeaturesKHR*" : "VkPhysicalDevicePortabilitySubsetFeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR: + dump_VkPhysicalDevicePortabilitySubsetPropertiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePortabilitySubsetPropertiesKHR*" : "VkPhysicalDevicePortabilitySubsetPropertiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; +#endif // VK_ENABLE_BETA_EXTENSIONS + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: + dump_VkPhysicalDeviceShaderClockFeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderClockFeaturesKHR*" : "VkPhysicalDeviceShaderClockFeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR: + dump_VkVideoDecodeH265ProfileInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeH265ProfileInfoKHR*" : "VkVideoDecodeH265ProfileInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR: + dump_VkVideoDecodeH265CapabilitiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeH265CapabilitiesKHR*" : "VkVideoDecodeH265CapabilitiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: + dump_VkVideoDecodeH265SessionParametersAddInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeH265SessionParametersAddInfoKHR*" : "VkVideoDecodeH265SessionParametersAddInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: + dump_VkVideoDecodeH265SessionParametersCreateInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeH265SessionParametersCreateInfoKHR*" : "VkVideoDecodeH265SessionParametersCreateInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR: + dump_VkVideoDecodeH265PictureInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeH265PictureInfoKHR*" : "VkVideoDecodeH265PictureInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR: + dump_VkVideoDecodeH265DpbSlotInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeH265DpbSlotInfoKHR*" : "VkVideoDecodeH265DpbSlotInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: + dump_VkFragmentShadingRateAttachmentInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkFragmentShadingRateAttachmentInfoKHR*" : "VkFragmentShadingRateAttachmentInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR: + dump_VkPipelineFragmentShadingRateStateCreateInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineFragmentShadingRateStateCreateInfoKHR*" : "VkPipelineFragmentShadingRateStateCreateInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: + dump_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFragmentShadingRateFeaturesKHR*" : "VkPhysicalDeviceFragmentShadingRateFeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR: + dump_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFragmentShadingRatePropertiesKHR*" : "VkPhysicalDeviceFragmentShadingRatePropertiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR: + dump_VkPhysicalDeviceFragmentShadingRateKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFragmentShadingRateKHR*" : "VkPhysicalDeviceFragmentShadingRateKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: + dump_VkRenderingFragmentShadingRateAttachmentInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderingFragmentShadingRateAttachmentInfoKHR*" : "VkRenderingFragmentShadingRateAttachmentInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR: + dump_VkPhysicalDeviceShaderQuadControlFeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderQuadControlFeaturesKHR*" : "VkPhysicalDeviceShaderQuadControlFeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR: + dump_VkSurfaceProtectedCapabilitiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSurfaceProtectedCapabilitiesKHR*" : "VkSurfaceProtectedCapabilitiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: + dump_VkPhysicalDevicePresentWaitFeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePresentWaitFeaturesKHR*" : "VkPhysicalDevicePresentWaitFeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: + dump_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*" : "VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR: + dump_VkPipelineInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineInfoKHR*" : "VkPipelineInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR: + dump_VkPipelineExecutablePropertiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineExecutablePropertiesKHR*" : "VkPipelineExecutablePropertiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR: + dump_VkPipelineExecutableInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineExecutableInfoKHR*" : "VkPipelineExecutableInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR: + dump_VkPipelineExecutableStatisticKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineExecutableStatisticKHR*" : "VkPipelineExecutableStatisticKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR: + dump_VkPipelineExecutableInternalRepresentationKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineExecutableInternalRepresentationKHR*" : "VkPipelineExecutableInternalRepresentationKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: + dump_VkPipelineLibraryCreateInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineLibraryCreateInfoKHR*" : "VkPipelineLibraryCreateInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PRESENT_ID_KHR: + dump_VkPresentIdKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPresentIdKHR*" : "VkPresentIdKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: + dump_VkPhysicalDevicePresentIdFeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePresentIdFeaturesKHR*" : "VkPhysicalDevicePresentIdFeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR: + dump_VkVideoEncodeInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeInfoKHR*" : "VkVideoEncodeInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR: + dump_VkVideoEncodeCapabilitiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeCapabilitiesKHR*" : "VkVideoEncodeCapabilitiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR: + dump_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkQueryPoolVideoEncodeFeedbackCreateInfoKHR*" : "VkQueryPoolVideoEncodeFeedbackCreateInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR: + dump_VkVideoEncodeUsageInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeUsageInfoKHR*" : "VkVideoEncodeUsageInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR: + dump_VkVideoEncodeRateControlLayerInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeRateControlLayerInfoKHR*" : "VkVideoEncodeRateControlLayerInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: + dump_VkVideoEncodeRateControlInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeRateControlInfoKHR*" : "VkVideoEncodeRateControlInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR: + dump_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR*" : "VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR: + dump_VkVideoEncodeQualityLevelPropertiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeQualityLevelPropertiesKHR*" : "VkVideoEncodeQualityLevelPropertiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR: + dump_VkVideoEncodeQualityLevelInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeQualityLevelInfoKHR*" : "VkVideoEncodeQualityLevelInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR: + dump_VkVideoEncodeSessionParametersGetInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeSessionParametersGetInfoKHR*" : "VkVideoEncodeSessionParametersGetInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: + dump_VkVideoEncodeSessionParametersFeedbackInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeSessionParametersFeedbackInfoKHR*" : "VkVideoEncodeSessionParametersFeedbackInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: + dump_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR*" : "VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR: + dump_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR*" : "VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: + dump_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*" : "VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: + dump_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR*" : "VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: + dump_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR*" : "VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR: + dump_VkPhysicalDeviceShaderUntypedPointersFeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderUntypedPointersFeaturesKHR*" : "VkPhysicalDeviceShaderUntypedPointersFeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: + dump_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR*" : "VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR: + dump_VkSurfaceCapabilitiesPresentId2KHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSurfaceCapabilitiesPresentId2KHR*" : "VkSurfaceCapabilitiesPresentId2KHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR: + dump_VkPresentId2KHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPresentId2KHR*" : "VkPresentId2KHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR: + dump_VkPhysicalDevicePresentId2FeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePresentId2FeaturesKHR*" : "VkPhysicalDevicePresentId2FeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR: + dump_VkSurfaceCapabilitiesPresentWait2KHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSurfaceCapabilitiesPresentWait2KHR*" : "VkSurfaceCapabilitiesPresentWait2KHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR: + dump_VkPhysicalDevicePresentWait2FeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePresentWait2FeaturesKHR*" : "VkPhysicalDevicePresentWait2FeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR: + dump_VkPresentWait2InfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPresentWait2InfoKHR*" : "VkPresentWait2InfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: + dump_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR*" : "VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR: + dump_VkPhysicalDevicePipelineBinaryFeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePipelineBinaryFeaturesKHR*" : "VkPhysicalDevicePipelineBinaryFeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR: + dump_VkPhysicalDevicePipelineBinaryPropertiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePipelineBinaryPropertiesKHR*" : "VkPhysicalDevicePipelineBinaryPropertiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR: + dump_VkDevicePipelineBinaryInternalCacheControlKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDevicePipelineBinaryInternalCacheControlKHR*" : "VkDevicePipelineBinaryInternalCacheControlKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR: + dump_VkPipelineBinaryKeyKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineBinaryKeyKHR*" : "VkPipelineBinaryKeyKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR: + dump_VkPipelineCreateInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineCreateInfoKHR*" : "VkPipelineCreateInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR: + dump_VkPipelineBinaryCreateInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineBinaryCreateInfoKHR*" : "VkPipelineBinaryCreateInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR: + dump_VkPipelineBinaryInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineBinaryInfoKHR*" : "VkPipelineBinaryInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR: + dump_VkReleaseCapturedPipelineDataInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkReleaseCapturedPipelineDataInfoKHR*" : "VkReleaseCapturedPipelineDataInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR: + dump_VkPipelineBinaryDataInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineBinaryDataInfoKHR*" : "VkPipelineBinaryDataInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR: + dump_VkPipelineBinaryHandlesInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineBinaryHandlesInfoKHR*" : "VkPipelineBinaryHandlesInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR: + dump_VkSurfacePresentModeKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSurfacePresentModeKHR*" : "VkSurfacePresentModeKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR: + dump_VkSurfacePresentScalingCapabilitiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSurfacePresentScalingCapabilitiesKHR*" : "VkSurfacePresentScalingCapabilitiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR: + dump_VkSurfacePresentModeCompatibilityKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSurfacePresentModeCompatibilityKHR*" : "VkSurfacePresentModeCompatibilityKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR: + dump_VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR*" : "VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR: + dump_VkSwapchainPresentFenceInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSwapchainPresentFenceInfoKHR*" : "VkSwapchainPresentFenceInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR: + dump_VkSwapchainPresentModesCreateInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSwapchainPresentModesCreateInfoKHR*" : "VkSwapchainPresentModesCreateInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR: + dump_VkSwapchainPresentModeInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSwapchainPresentModeInfoKHR*" : "VkSwapchainPresentModeInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR: + dump_VkSwapchainPresentScalingCreateInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSwapchainPresentScalingCreateInfoKHR*" : "VkSwapchainPresentScalingCreateInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR: + dump_VkReleaseSwapchainImagesInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkReleaseSwapchainImagesInfoKHR*" : "VkReleaseSwapchainImagesInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR: + dump_VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR*" : "VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR: + dump_VkCooperativeMatrixPropertiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCooperativeMatrixPropertiesKHR*" : "VkCooperativeMatrixPropertiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR: + dump_VkPhysicalDeviceCooperativeMatrixFeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCooperativeMatrixFeaturesKHR*" : "VkPhysicalDeviceCooperativeMatrixFeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR: + dump_VkPhysicalDeviceCooperativeMatrixPropertiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCooperativeMatrixPropertiesKHR*" : "VkPhysicalDeviceCooperativeMatrixPropertiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR: + dump_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR*" : "VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR: + dump_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR*" : "VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR: + dump_VkVideoDecodeAV1ProfileInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeAV1ProfileInfoKHR*" : "VkVideoDecodeAV1ProfileInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR: + dump_VkVideoDecodeAV1CapabilitiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeAV1CapabilitiesKHR*" : "VkVideoDecodeAV1CapabilitiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR: + dump_VkVideoDecodeAV1SessionParametersCreateInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeAV1SessionParametersCreateInfoKHR*" : "VkVideoDecodeAV1SessionParametersCreateInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR: + dump_VkVideoDecodeAV1PictureInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeAV1PictureInfoKHR*" : "VkVideoDecodeAV1PictureInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR: + dump_VkVideoDecodeAV1DpbSlotInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeAV1DpbSlotInfoKHR*" : "VkVideoDecodeAV1DpbSlotInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR: + dump_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVideoEncodeAV1FeaturesKHR*" : "VkPhysicalDeviceVideoEncodeAV1FeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR: + dump_VkVideoEncodeAV1CapabilitiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeAV1CapabilitiesKHR*" : "VkVideoEncodeAV1CapabilitiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR: + dump_VkVideoEncodeAV1QualityLevelPropertiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeAV1QualityLevelPropertiesKHR*" : "VkVideoEncodeAV1QualityLevelPropertiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR: + dump_VkVideoEncodeAV1SessionCreateInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeAV1SessionCreateInfoKHR*" : "VkVideoEncodeAV1SessionCreateInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR: + dump_VkVideoEncodeAV1SessionParametersCreateInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeAV1SessionParametersCreateInfoKHR*" : "VkVideoEncodeAV1SessionParametersCreateInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR: + dump_VkVideoEncodeAV1PictureInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeAV1PictureInfoKHR*" : "VkVideoEncodeAV1PictureInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR: + dump_VkVideoEncodeAV1DpbSlotInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeAV1DpbSlotInfoKHR*" : "VkVideoEncodeAV1DpbSlotInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR: + dump_VkVideoEncodeAV1ProfileInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeAV1ProfileInfoKHR*" : "VkVideoEncodeAV1ProfileInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR: + dump_VkVideoEncodeAV1GopRemainingFrameInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeAV1GopRemainingFrameInfoKHR*" : "VkVideoEncodeAV1GopRemainingFrameInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR: + dump_VkVideoEncodeAV1RateControlInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeAV1RateControlInfoKHR*" : "VkVideoEncodeAV1RateControlInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR: + dump_VkVideoEncodeAV1RateControlLayerInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeAV1RateControlLayerInfoKHR*" : "VkVideoEncodeAV1RateControlLayerInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR: + dump_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVideoDecodeVP9FeaturesKHR*" : "VkPhysicalDeviceVideoDecodeVP9FeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR: + dump_VkVideoDecodeVP9ProfileInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeVP9ProfileInfoKHR*" : "VkVideoDecodeVP9ProfileInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR: + dump_VkVideoDecodeVP9CapabilitiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeVP9CapabilitiesKHR*" : "VkVideoDecodeVP9CapabilitiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR: + dump_VkVideoDecodeVP9PictureInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeVP9PictureInfoKHR*" : "VkVideoDecodeVP9PictureInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: + dump_VkPhysicalDeviceVideoMaintenance1FeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVideoMaintenance1FeaturesKHR*" : "VkPhysicalDeviceVideoMaintenance1FeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR: + dump_VkVideoInlineQueryInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoInlineQueryInfoKHR*" : "VkVideoInlineQueryInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR: + dump_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR*" : "VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT: + dump_VkAttachmentFeedbackLoopInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkAttachmentFeedbackLoopInfoEXT*" : "VkAttachmentFeedbackLoopInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR: + dump_VkCalibratedTimestampInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCalibratedTimestampInfoKHR*" : "VkCalibratedTimestampInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT: + dump_VkSetDescriptorBufferOffsetsInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSetDescriptorBufferOffsetsInfoEXT*" : "VkSetDescriptorBufferOffsetsInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT: + dump_VkBindDescriptorBufferEmbeddedSamplersInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkBindDescriptorBufferEmbeddedSamplersInfoEXT*" : "VkBindDescriptorBufferEmbeddedSamplersInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_COPY_MEMORY_INDIRECT_INFO_KHR: + dump_VkCopyMemoryIndirectInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCopyMemoryIndirectInfoKHR*" : "VkCopyMemoryIndirectInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INDIRECT_INFO_KHR: + dump_VkCopyMemoryToImageIndirectInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCopyMemoryToImageIndirectInfoKHR*" : "VkCopyMemoryToImageIndirectInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR: + dump_VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR*" : "VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR: + dump_VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR*" : "VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR: + dump_VkVideoEncodeIntraRefreshCapabilitiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeIntraRefreshCapabilitiesKHR*" : "VkVideoEncodeIntraRefreshCapabilitiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR: + dump_VkVideoEncodeSessionIntraRefreshCreateInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeSessionIntraRefreshCreateInfoKHR*" : "VkVideoEncodeSessionIntraRefreshCreateInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR: + dump_VkVideoEncodeIntraRefreshInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeIntraRefreshInfoKHR*" : "VkVideoEncodeIntraRefreshInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR: + dump_VkVideoReferenceIntraRefreshInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoReferenceIntraRefreshInfoKHR*" : "VkVideoReferenceIntraRefreshInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR: + dump_VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR*" : "VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR: + dump_VkVideoEncodeQuantizationMapCapabilitiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeQuantizationMapCapabilitiesKHR*" : "VkVideoEncodeQuantizationMapCapabilitiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR: + dump_VkVideoFormatQuantizationMapPropertiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoFormatQuantizationMapPropertiesKHR*" : "VkVideoFormatQuantizationMapPropertiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR: + dump_VkVideoEncodeQuantizationMapInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeQuantizationMapInfoKHR*" : "VkVideoEncodeQuantizationMapInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR: + dump_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR*" : "VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR: + dump_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR*" : "VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR: + dump_VkVideoEncodeH264QuantizationMapCapabilitiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH264QuantizationMapCapabilitiesKHR*" : "VkVideoEncodeH264QuantizationMapCapabilitiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR: + dump_VkVideoEncodeH265QuantizationMapCapabilitiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeH265QuantizationMapCapabilitiesKHR*" : "VkVideoEncodeH265QuantizationMapCapabilitiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR: + dump_VkVideoFormatH265QuantizationMapPropertiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoFormatH265QuantizationMapPropertiesKHR*" : "VkVideoFormatH265QuantizationMapPropertiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR: + dump_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeAV1QuantizationMapCapabilitiesKHR*" : "VkVideoEncodeAV1QuantizationMapCapabilitiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR: + dump_VkVideoFormatAV1QuantizationMapPropertiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoFormatAV1QuantizationMapPropertiesKHR*" : "VkVideoFormatAV1QuantizationMapPropertiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR: + dump_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR*" : "VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR: + dump_VkPhysicalDeviceMaintenance7FeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMaintenance7FeaturesKHR*" : "VkPhysicalDeviceMaintenance7FeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR: + dump_VkPhysicalDeviceMaintenance7PropertiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMaintenance7PropertiesKHR*" : "VkPhysicalDeviceMaintenance7PropertiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR: + dump_VkPhysicalDeviceLayeredApiPropertiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceLayeredApiPropertiesKHR*" : "VkPhysicalDeviceLayeredApiPropertiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR: + dump_VkPhysicalDeviceLayeredApiPropertiesListKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceLayeredApiPropertiesListKHR*" : "VkPhysicalDeviceLayeredApiPropertiesListKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR: + dump_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceLayeredApiVulkanPropertiesKHR*" : "VkPhysicalDeviceLayeredApiVulkanPropertiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR: + dump_VkMemoryBarrierAccessFlags3KHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryBarrierAccessFlags3KHR*" : "VkMemoryBarrierAccessFlags3KHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR: + dump_VkPhysicalDeviceMaintenance8FeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMaintenance8FeaturesKHR*" : "VkPhysicalDeviceMaintenance8FeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR: + dump_VkPhysicalDeviceShaderFmaFeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderFmaFeaturesKHR*" : "VkPhysicalDeviceShaderFmaFeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR: + dump_VkPhysicalDeviceMaintenance9FeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMaintenance9FeaturesKHR*" : "VkPhysicalDeviceMaintenance9FeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR: + dump_VkPhysicalDeviceMaintenance9PropertiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMaintenance9PropertiesKHR*" : "VkPhysicalDeviceMaintenance9PropertiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR: + dump_VkQueueFamilyOwnershipTransferPropertiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkQueueFamilyOwnershipTransferPropertiesKHR*" : "VkQueueFamilyOwnershipTransferPropertiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR: + dump_VkPhysicalDeviceVideoMaintenance2FeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVideoMaintenance2FeaturesKHR*" : "VkPhysicalDeviceVideoMaintenance2FeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR: + dump_VkVideoDecodeH264InlineSessionParametersInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeH264InlineSessionParametersInfoKHR*" : "VkVideoDecodeH264InlineSessionParametersInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR: + dump_VkVideoDecodeH265InlineSessionParametersInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeH265InlineSessionParametersInfoKHR*" : "VkVideoDecodeH265InlineSessionParametersInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR: + dump_VkVideoDecodeAV1InlineSessionParametersInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoDecodeAV1InlineSessionParametersInfoKHR*" : "VkVideoDecodeAV1InlineSessionParametersInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR: + dump_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDepthClampZeroOneFeaturesKHR*" : "VkPhysicalDeviceDepthClampZeroOneFeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR: + dump_VkPhysicalDeviceRobustness2FeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRobustness2FeaturesKHR*" : "VkPhysicalDeviceRobustness2FeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR: + dump_VkPhysicalDeviceRobustness2PropertiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRobustness2PropertiesKHR*" : "VkPhysicalDeviceRobustness2PropertiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR: + dump_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR*" : "VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR: + dump_VkPhysicalDeviceMaintenance10FeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMaintenance10FeaturesKHR*" : "VkPhysicalDeviceMaintenance10FeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR: + dump_VkPhysicalDeviceMaintenance10PropertiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMaintenance10PropertiesKHR*" : "VkPhysicalDeviceMaintenance10PropertiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR: + dump_VkRenderingEndInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderingEndInfoKHR*" : "VkRenderingEndInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_FLAGS_INFO_KHR: + dump_VkRenderingAttachmentFlagsInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderingAttachmentFlagsInfoKHR*" : "VkRenderingAttachmentFlagsInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_RESOLVE_IMAGE_MODE_INFO_KHR: + dump_VkResolveImageModeInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkResolveImageModeInfoKHR*" : "VkResolveImageModeInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: + dump_VkDebugReportCallbackCreateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDebugReportCallbackCreateInfoEXT*" : "VkDebugReportCallbackCreateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: + dump_VkPipelineRasterizationStateRasterizationOrderAMD(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineRasterizationStateRasterizationOrderAMD*" : "VkPipelineRasterizationStateRasterizationOrderAMD"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT: + dump_VkDebugMarkerObjectNameInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDebugMarkerObjectNameInfoEXT*" : "VkDebugMarkerObjectNameInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT: + dump_VkDebugMarkerObjectTagInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDebugMarkerObjectTagInfoEXT*" : "VkDebugMarkerObjectTagInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT: + dump_VkDebugMarkerMarkerInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDebugMarkerMarkerInfoEXT*" : "VkDebugMarkerMarkerInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: + dump_VkDedicatedAllocationImageCreateInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDedicatedAllocationImageCreateInfoNV*" : "VkDedicatedAllocationImageCreateInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: + dump_VkDedicatedAllocationBufferCreateInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDedicatedAllocationBufferCreateInfoNV*" : "VkDedicatedAllocationBufferCreateInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: + dump_VkDedicatedAllocationMemoryAllocateInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDedicatedAllocationMemoryAllocateInfoNV*" : "VkDedicatedAllocationMemoryAllocateInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: + dump_VkPhysicalDeviceTransformFeedbackFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceTransformFeedbackFeaturesEXT*" : "VkPhysicalDeviceTransformFeedbackFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: + dump_VkPhysicalDeviceTransformFeedbackPropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceTransformFeedbackPropertiesEXT*" : "VkPhysicalDeviceTransformFeedbackPropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: + dump_VkPipelineRasterizationStateStreamCreateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineRasterizationStateStreamCreateInfoEXT*" : "VkPipelineRasterizationStateStreamCreateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX: + dump_VkCuModuleCreateInfoNVX(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCuModuleCreateInfoNVX*" : "VkCuModuleCreateInfoNVX"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX: + dump_VkCuModuleTexturingModeCreateInfoNVX(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCuModuleTexturingModeCreateInfoNVX*" : "VkCuModuleTexturingModeCreateInfoNVX"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX: + dump_VkCuFunctionCreateInfoNVX(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCuFunctionCreateInfoNVX*" : "VkCuFunctionCreateInfoNVX"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX: + dump_VkCuLaunchInfoNVX(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCuLaunchInfoNVX*" : "VkCuLaunchInfoNVX"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX: + dump_VkImageViewHandleInfoNVX(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImageViewHandleInfoNVX*" : "VkImageViewHandleInfoNVX"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX: + dump_VkImageViewAddressPropertiesNVX(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImageViewAddressPropertiesNVX*" : "VkImageViewAddressPropertiesNVX"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: + dump_VkTextureLODGatherFormatPropertiesAMD(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkTextureLODGatherFormatPropertiesAMD*" : "VkTextureLODGatherFormatPropertiesAMD"), "pNext", indents, reinterpret_cast(object)); + break; +#if defined(VK_USE_PLATFORM_GGP) + + case VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP: + dump_VkStreamDescriptorSurfaceCreateInfoGGP(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkStreamDescriptorSurfaceCreateInfoGGP*" : "VkStreamDescriptorSurfaceCreateInfoGGP"), "pNext", indents, reinterpret_cast(object)); + break; +#endif // VK_USE_PLATFORM_GGP + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: + dump_VkPhysicalDeviceCornerSampledImageFeaturesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCornerSampledImageFeaturesNV*" : "VkPhysicalDeviceCornerSampledImageFeaturesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV: + dump_VkExternalMemoryImageCreateInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkExternalMemoryImageCreateInfoNV*" : "VkExternalMemoryImageCreateInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV: + dump_VkExportMemoryAllocateInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkExportMemoryAllocateInfoNV*" : "VkExportMemoryAllocateInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; +#if defined(VK_USE_PLATFORM_WIN32_KHR) + + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV: + dump_VkImportMemoryWin32HandleInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImportMemoryWin32HandleInfoNV*" : "VkImportMemoryWin32HandleInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV: + dump_VkExportMemoryWin32HandleInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkExportMemoryWin32HandleInfoNV*" : "VkExportMemoryWin32HandleInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV: + dump_VkWin32KeyedMutexAcquireReleaseInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkWin32KeyedMutexAcquireReleaseInfoNV*" : "VkWin32KeyedMutexAcquireReleaseInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; +#endif // VK_USE_PLATFORM_WIN32_KHR + + case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT: + dump_VkValidationFlagsEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkValidationFlagsEXT*" : "VkValidationFlagsEXT"), "pNext", indents, reinterpret_cast(object)); + break; +#if defined(VK_USE_PLATFORM_VI_NN) + + case VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN: + dump_VkViSurfaceCreateInfoNN(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkViSurfaceCreateInfoNN*" : "VkViSurfaceCreateInfoNN"), "pNext", indents, reinterpret_cast(object)); + break; +#endif // VK_USE_PLATFORM_VI_NN + + case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: + dump_VkImageViewASTCDecodeModeEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImageViewASTCDecodeModeEXT*" : "VkImageViewASTCDecodeModeEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: + dump_VkPhysicalDeviceASTCDecodeFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceASTCDecodeFeaturesEXT*" : "VkPhysicalDeviceASTCDecodeFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT: + dump_VkConditionalRenderingBeginInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkConditionalRenderingBeginInfoEXT*" : "VkConditionalRenderingBeginInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: + dump_VkPhysicalDeviceConditionalRenderingFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceConditionalRenderingFeaturesEXT*" : "VkPhysicalDeviceConditionalRenderingFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT: + dump_VkCommandBufferInheritanceConditionalRenderingInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCommandBufferInheritanceConditionalRenderingInfoEXT*" : "VkCommandBufferInheritanceConditionalRenderingInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: + dump_VkPipelineViewportWScalingStateCreateInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineViewportWScalingStateCreateInfoNV*" : "VkPipelineViewportWScalingStateCreateInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT: + dump_VkSurfaceCapabilities2EXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSurfaceCapabilities2EXT*" : "VkSurfaceCapabilities2EXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT: + dump_VkDisplayPowerInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDisplayPowerInfoEXT*" : "VkDisplayPowerInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT: + dump_VkDeviceEventInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceEventInfoEXT*" : "VkDeviceEventInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT: + dump_VkDisplayEventInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDisplayEventInfoEXT*" : "VkDisplayEventInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT: + dump_VkSwapchainCounterCreateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSwapchainCounterCreateInfoEXT*" : "VkSwapchainCounterCreateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE: + dump_VkPresentTimesInfoGOOGLE(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPresentTimesInfoGOOGLE*" : "VkPresentTimesInfoGOOGLE"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX: + dump_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*" : "VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: + dump_VkMultiviewPerViewAttributesInfoNVX(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkMultiviewPerViewAttributesInfoNVX*" : "VkMultiviewPerViewAttributesInfoNVX"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: + dump_VkPipelineViewportSwizzleStateCreateInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineViewportSwizzleStateCreateInfoNV*" : "VkPipelineViewportSwizzleStateCreateInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: + dump_VkPhysicalDeviceDiscardRectanglePropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDiscardRectanglePropertiesEXT*" : "VkPhysicalDeviceDiscardRectanglePropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: + dump_VkPipelineDiscardRectangleStateCreateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineDiscardRectangleStateCreateInfoEXT*" : "VkPipelineDiscardRectangleStateCreateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: + dump_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceConservativeRasterizationPropertiesEXT*" : "VkPhysicalDeviceConservativeRasterizationPropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: + dump_VkPipelineRasterizationConservativeStateCreateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineRasterizationConservativeStateCreateInfoEXT*" : "VkPipelineRasterizationConservativeStateCreateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: + dump_VkPhysicalDeviceDepthClipEnableFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDepthClipEnableFeaturesEXT*" : "VkPhysicalDeviceDepthClipEnableFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: + dump_VkPipelineRasterizationDepthClipStateCreateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineRasterizationDepthClipStateCreateInfoEXT*" : "VkPipelineRasterizationDepthClipStateCreateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_HDR_METADATA_EXT: + dump_VkHdrMetadataEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkHdrMetadataEXT*" : "VkHdrMetadataEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: + dump_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG*" : "VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG"), "pNext", indents, reinterpret_cast(object)); + break; +#if defined(VK_USE_PLATFORM_IOS_MVK) + + case VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK: + dump_VkIOSSurfaceCreateInfoMVK(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkIOSSurfaceCreateInfoMVK*" : "VkIOSSurfaceCreateInfoMVK"), "pNext", indents, reinterpret_cast(object)); + break; +#endif // VK_USE_PLATFORM_IOS_MVK +#if defined(VK_USE_PLATFORM_MACOS_MVK) + + case VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK: + dump_VkMacOSSurfaceCreateInfoMVK(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkMacOSSurfaceCreateInfoMVK*" : "VkMacOSSurfaceCreateInfoMVK"), "pNext", indents, reinterpret_cast(object)); + break; +#endif // VK_USE_PLATFORM_MACOS_MVK + + case VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT: + dump_VkDebugUtilsLabelEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDebugUtilsLabelEXT*" : "VkDebugUtilsLabelEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: + dump_VkDebugUtilsObjectNameInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDebugUtilsObjectNameInfoEXT*" : "VkDebugUtilsObjectNameInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT: + dump_VkDebugUtilsMessengerCallbackDataEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDebugUtilsMessengerCallbackDataEXT*" : "VkDebugUtilsMessengerCallbackDataEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: + dump_VkDebugUtilsMessengerCreateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDebugUtilsMessengerCreateInfoEXT*" : "VkDebugUtilsMessengerCreateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT: + dump_VkDebugUtilsObjectTagInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDebugUtilsObjectTagInfoEXT*" : "VkDebugUtilsObjectTagInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; +#if defined(VK_USE_PLATFORM_ANDROID_KHR) + + case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID: + dump_VkAndroidHardwareBufferUsageANDROID(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkAndroidHardwareBufferUsageANDROID*" : "VkAndroidHardwareBufferUsageANDROID"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID: + dump_VkAndroidHardwareBufferPropertiesANDROID(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkAndroidHardwareBufferPropertiesANDROID*" : "VkAndroidHardwareBufferPropertiesANDROID"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID: + dump_VkAndroidHardwareBufferFormatPropertiesANDROID(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkAndroidHardwareBufferFormatPropertiesANDROID*" : "VkAndroidHardwareBufferFormatPropertiesANDROID"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: + dump_VkImportAndroidHardwareBufferInfoANDROID(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImportAndroidHardwareBufferInfoANDROID*" : "VkImportAndroidHardwareBufferInfoANDROID"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: + dump_VkMemoryGetAndroidHardwareBufferInfoANDROID(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryGetAndroidHardwareBufferInfoANDROID*" : "VkMemoryGetAndroidHardwareBufferInfoANDROID"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID: + dump_VkExternalFormatANDROID(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkExternalFormatANDROID*" : "VkExternalFormatANDROID"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID: + dump_VkAndroidHardwareBufferFormatProperties2ANDROID(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkAndroidHardwareBufferFormatProperties2ANDROID*" : "VkAndroidHardwareBufferFormatProperties2ANDROID"), "pNext", indents, reinterpret_cast(object)); + break; +#endif // VK_USE_PLATFORM_ANDROID_KHR +#if defined(VK_ENABLE_BETA_EXTENSIONS) + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX: + dump_VkPhysicalDeviceShaderEnqueueFeaturesAMDX(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderEnqueueFeaturesAMDX*" : "VkPhysicalDeviceShaderEnqueueFeaturesAMDX"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX: + dump_VkPhysicalDeviceShaderEnqueuePropertiesAMDX(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderEnqueuePropertiesAMDX*" : "VkPhysicalDeviceShaderEnqueuePropertiesAMDX"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX: + dump_VkExecutionGraphPipelineScratchSizeAMDX(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkExecutionGraphPipelineScratchSizeAMDX*" : "VkExecutionGraphPipelineScratchSizeAMDX"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX: + dump_VkExecutionGraphPipelineCreateInfoAMDX(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkExecutionGraphPipelineCreateInfoAMDX*" : "VkExecutionGraphPipelineCreateInfoAMDX"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX: + dump_VkPipelineShaderStageNodeCreateInfoAMDX(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineShaderStageNodeCreateInfoAMDX*" : "VkPipelineShaderStageNodeCreateInfoAMDX"), "pNext", indents, reinterpret_cast(object)); + break; +#endif // VK_ENABLE_BETA_EXTENSIONS + + case VK_STRUCTURE_TYPE_TEXEL_BUFFER_DESCRIPTOR_INFO_EXT: + dump_VkTexelBufferDescriptorInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkTexelBufferDescriptorInfoEXT*" : "VkTexelBufferDescriptorInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMAGE_DESCRIPTOR_INFO_EXT: + dump_VkImageDescriptorInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImageDescriptorInfoEXT*" : "VkImageDescriptorInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM: + dump_VkTensorViewCreateInfoARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkTensorViewCreateInfoARM*" : "VkTensorViewCreateInfoARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT: + dump_VkResourceDescriptorInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkResourceDescriptorInfoEXT*" : "VkResourceDescriptorInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_BIND_HEAP_INFO_EXT: + dump_VkBindHeapInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkBindHeapInfoEXT*" : "VkBindHeapInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PUSH_DATA_INFO_EXT: + dump_VkPushDataInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPushDataInfoEXT*" : "VkPushDataInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_AND_BINDING_MAPPING_EXT: + dump_VkDescriptorSetAndBindingMappingEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDescriptorSetAndBindingMappingEXT*" : "VkDescriptorSetAndBindingMappingEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SHADER_DESCRIPTOR_SET_AND_BINDING_MAPPING_INFO_EXT: + dump_VkShaderDescriptorSetAndBindingMappingInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkShaderDescriptorSetAndBindingMappingInfoEXT*" : "VkShaderDescriptorSetAndBindingMappingInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DATA_CREATE_INFO_EXT: + dump_VkOpaqueCaptureDataCreateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkOpaqueCaptureDataCreateInfoEXT*" : "VkOpaqueCaptureDataCreateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT: + dump_VkPhysicalDeviceDescriptorHeapFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDescriptorHeapFeaturesEXT*" : "VkPhysicalDeviceDescriptorHeapFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES_EXT: + dump_VkPhysicalDeviceDescriptorHeapPropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDescriptorHeapPropertiesEXT*" : "VkPhysicalDeviceDescriptorHeapPropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_DESCRIPTOR_HEAP_INFO_EXT: + dump_VkCommandBufferInheritanceDescriptorHeapInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCommandBufferInheritanceDescriptorHeapInfoEXT*" : "VkCommandBufferInheritanceDescriptorHeapInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_INDEX_CREATE_INFO_EXT: + dump_VkSamplerCustomBorderColorIndexCreateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSamplerCustomBorderColorIndexCreateInfoEXT*" : "VkSamplerCustomBorderColorIndexCreateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: + dump_VkSamplerCustomBorderColorCreateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSamplerCustomBorderColorCreateInfoEXT*" : "VkSamplerCustomBorderColorCreateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_PUSH_DATA_TOKEN_NV: + dump_VkIndirectCommandsLayoutPushDataTokenNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkIndirectCommandsLayoutPushDataTokenNV*" : "VkIndirectCommandsLayoutPushDataTokenNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SUBSAMPLED_IMAGE_FORMAT_PROPERTIES_EXT: + dump_VkSubsampledImageFormatPropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSubsampledImageFormatPropertiesEXT*" : "VkSubsampledImageFormatPropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_TENSOR_PROPERTIES_ARM: + dump_VkPhysicalDeviceDescriptorHeapTensorPropertiesARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDescriptorHeapTensorPropertiesARM*" : "VkPhysicalDeviceDescriptorHeapTensorPropertiesARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: + dump_VkAttachmentSampleCountInfoAMD(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkAttachmentSampleCountInfoAMD*" : "VkAttachmentSampleCountInfoAMD"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: + dump_VkSampleLocationsInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSampleLocationsInfoEXT*" : "VkSampleLocationsInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT: + dump_VkRenderPassSampleLocationsBeginInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderPassSampleLocationsBeginInfoEXT*" : "VkRenderPassSampleLocationsBeginInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: + dump_VkPipelineSampleLocationsStateCreateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineSampleLocationsStateCreateInfoEXT*" : "VkPipelineSampleLocationsStateCreateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: + dump_VkPhysicalDeviceSampleLocationsPropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceSampleLocationsPropertiesEXT*" : "VkPhysicalDeviceSampleLocationsPropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT: + dump_VkMultisamplePropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkMultisamplePropertiesEXT*" : "VkMultisamplePropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: + dump_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*" : "VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: + dump_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*" : "VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: + dump_VkPipelineColorBlendAdvancedStateCreateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineColorBlendAdvancedStateCreateInfoEXT*" : "VkPipelineColorBlendAdvancedStateCreateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: + dump_VkPipelineCoverageToColorStateCreateInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineCoverageToColorStateCreateInfoNV*" : "VkPipelineCoverageToColorStateCreateInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: + dump_VkPipelineCoverageModulationStateCreateInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineCoverageModulationStateCreateInfoNV*" : "VkPipelineCoverageModulationStateCreateInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV: + dump_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*" : "VkPhysicalDeviceShaderSMBuiltinsPropertiesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: + dump_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*" : "VkPhysicalDeviceShaderSMBuiltinsFeaturesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: + dump_VkDrmFormatModifierPropertiesListEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDrmFormatModifierPropertiesListEXT*" : "VkDrmFormatModifierPropertiesListEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT: + dump_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceImageDrmFormatModifierInfoEXT*" : "VkPhysicalDeviceImageDrmFormatModifierInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: + dump_VkImageDrmFormatModifierListCreateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImageDrmFormatModifierListCreateInfoEXT*" : "VkImageDrmFormatModifierListCreateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: + dump_VkImageDrmFormatModifierExplicitCreateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImageDrmFormatModifierExplicitCreateInfoEXT*" : "VkImageDrmFormatModifierExplicitCreateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT: + dump_VkImageDrmFormatModifierPropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImageDrmFormatModifierPropertiesEXT*" : "VkImageDrmFormatModifierPropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT: + dump_VkDrmFormatModifierPropertiesList2EXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDrmFormatModifierPropertiesList2EXT*" : "VkDrmFormatModifierPropertiesList2EXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT: + dump_VkValidationCacheCreateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkValidationCacheCreateInfoEXT*" : "VkValidationCacheCreateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: + dump_VkShaderModuleValidationCacheCreateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkShaderModuleValidationCacheCreateInfoEXT*" : "VkShaderModuleValidationCacheCreateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV: + dump_VkPipelineViewportShadingRateImageStateCreateInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineViewportShadingRateImageStateCreateInfoNV*" : "VkPipelineViewportShadingRateImageStateCreateInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: + dump_VkPhysicalDeviceShadingRateImageFeaturesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShadingRateImageFeaturesNV*" : "VkPhysicalDeviceShadingRateImageFeaturesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV: + dump_VkPhysicalDeviceShadingRateImagePropertiesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShadingRateImagePropertiesNV*" : "VkPhysicalDeviceShadingRateImagePropertiesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV: + dump_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*" : "VkPipelineViewportCoarseSampleOrderStateCreateInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV: + dump_VkRayTracingShaderGroupCreateInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkRayTracingShaderGroupCreateInfoNV*" : "VkRayTracingShaderGroupCreateInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV: + dump_VkRayTracingPipelineCreateInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkRayTracingPipelineCreateInfoNV*" : "VkRayTracingPipelineCreateInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV: + dump_VkGeometryTrianglesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkGeometryTrianglesNV*" : "VkGeometryTrianglesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV: + dump_VkGeometryAABBNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkGeometryAABBNV*" : "VkGeometryAABBNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_GEOMETRY_NV: + dump_VkGeometryNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkGeometryNV*" : "VkGeometryNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV: + dump_VkAccelerationStructureInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureInfoNV*" : "VkAccelerationStructureInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV: + dump_VkAccelerationStructureCreateInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureCreateInfoNV*" : "VkAccelerationStructureCreateInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV: + dump_VkBindAccelerationStructureMemoryInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkBindAccelerationStructureMemoryInfoNV*" : "VkBindAccelerationStructureMemoryInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV: + dump_VkWriteDescriptorSetAccelerationStructureNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkWriteDescriptorSetAccelerationStructureNV*" : "VkWriteDescriptorSetAccelerationStructureNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV: + dump_VkAccelerationStructureMemoryRequirementsInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureMemoryRequirementsInfoNV*" : "VkAccelerationStructureMemoryRequirementsInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV: + dump_VkPhysicalDeviceRayTracingPropertiesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRayTracingPropertiesNV*" : "VkPhysicalDeviceRayTracingPropertiesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: + dump_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*" : "VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV: + dump_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineRepresentativeFragmentTestStateCreateInfoNV*" : "VkPipelineRepresentativeFragmentTestStateCreateInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT: + dump_VkPhysicalDeviceImageViewImageFormatInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceImageViewImageFormatInfoEXT*" : "VkPhysicalDeviceImageViewImageFormatInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT: + dump_VkFilterCubicImageViewImageFormatPropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkFilterCubicImageViewImageFormatPropertiesEXT*" : "VkFilterCubicImageViewImageFormatPropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: + dump_VkImportMemoryHostPointerInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImportMemoryHostPointerInfoEXT*" : "VkImportMemoryHostPointerInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT: + dump_VkMemoryHostPointerPropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryHostPointerPropertiesEXT*" : "VkMemoryHostPointerPropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: + dump_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceExternalMemoryHostPropertiesEXT*" : "VkPhysicalDeviceExternalMemoryHostPropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: + dump_VkPipelineCompilerControlCreateInfoAMD(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineCompilerControlCreateInfoAMD*" : "VkPipelineCompilerControlCreateInfoAMD"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: + dump_VkPhysicalDeviceShaderCorePropertiesAMD(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderCorePropertiesAMD*" : "VkPhysicalDeviceShaderCorePropertiesAMD"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: + dump_VkDeviceMemoryOverallocationCreateInfoAMD(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceMemoryOverallocationCreateInfoAMD*" : "VkDeviceMemoryOverallocationCreateInfoAMD"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: + dump_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*" : "VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; +#if defined(VK_USE_PLATFORM_GGP) + + case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP: + dump_VkPresentFrameTokenGGP(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPresentFrameTokenGGP*" : "VkPresentFrameTokenGGP"), "pNext", indents, reinterpret_cast(object)); + break; +#endif // VK_USE_PLATFORM_GGP + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: + dump_VkPhysicalDeviceMeshShaderFeaturesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMeshShaderFeaturesNV*" : "VkPhysicalDeviceMeshShaderFeaturesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV: + dump_VkPhysicalDeviceMeshShaderPropertiesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMeshShaderPropertiesNV*" : "VkPhysicalDeviceMeshShaderPropertiesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: + dump_VkPhysicalDeviceShaderImageFootprintFeaturesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderImageFootprintFeaturesNV*" : "VkPhysicalDeviceShaderImageFootprintFeaturesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV: + dump_VkPipelineViewportExclusiveScissorStateCreateInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineViewportExclusiveScissorStateCreateInfoNV*" : "VkPipelineViewportExclusiveScissorStateCreateInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: + dump_VkPhysicalDeviceExclusiveScissorFeaturesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceExclusiveScissorFeaturesNV*" : "VkPhysicalDeviceExclusiveScissorFeaturesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV: + dump_VkQueueFamilyCheckpointPropertiesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkQueueFamilyCheckpointPropertiesNV*" : "VkQueueFamilyCheckpointPropertiesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV: + dump_VkCheckpointDataNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCheckpointDataNV*" : "VkCheckpointDataNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: + dump_VkQueueFamilyCheckpointProperties2NV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkQueueFamilyCheckpointProperties2NV*" : "VkQueueFamilyCheckpointProperties2NV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV: + dump_VkCheckpointData2NV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCheckpointData2NV*" : "VkCheckpointData2NV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT: + dump_VkPhysicalDevicePresentTimingFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePresentTimingFeaturesEXT*" : "VkPhysicalDevicePresentTimingFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT: + dump_VkPresentTimingSurfaceCapabilitiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPresentTimingSurfaceCapabilitiesEXT*" : "VkPresentTimingSurfaceCapabilitiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT: + dump_VkSwapchainCalibratedTimestampInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSwapchainCalibratedTimestampInfoEXT*" : "VkSwapchainCalibratedTimestampInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SWAPCHAIN_TIMING_PROPERTIES_EXT: + dump_VkSwapchainTimingPropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSwapchainTimingPropertiesEXT*" : "VkSwapchainTimingPropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SWAPCHAIN_TIME_DOMAIN_PROPERTIES_EXT: + dump_VkSwapchainTimeDomainPropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSwapchainTimeDomainPropertiesEXT*" : "VkSwapchainTimeDomainPropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_INFO_EXT: + dump_VkPastPresentationTimingInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPastPresentationTimingInfoEXT*" : "VkPastPresentationTimingInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_EXT: + dump_VkPastPresentationTimingEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPastPresentationTimingEXT*" : "VkPastPresentationTimingEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_PROPERTIES_EXT: + dump_VkPastPresentationTimingPropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPastPresentationTimingPropertiesEXT*" : "VkPastPresentationTimingPropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PRESENT_TIMING_INFO_EXT: + dump_VkPresentTimingInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPresentTimingInfoEXT*" : "VkPresentTimingInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT: + dump_VkPresentTimingsInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPresentTimingsInfoEXT*" : "VkPresentTimingsInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: + dump_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*" : "VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL: + dump_VkInitializePerformanceApiInfoINTEL(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkInitializePerformanceApiInfoINTEL*" : "VkInitializePerformanceApiInfoINTEL"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL: + dump_VkQueryPoolPerformanceQueryCreateInfoINTEL(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkQueryPoolPerformanceQueryCreateInfoINTEL*" : "VkQueryPoolPerformanceQueryCreateInfoINTEL"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL: + dump_VkPerformanceMarkerInfoINTEL(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPerformanceMarkerInfoINTEL*" : "VkPerformanceMarkerInfoINTEL"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL: + dump_VkPerformanceStreamMarkerInfoINTEL(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPerformanceStreamMarkerInfoINTEL*" : "VkPerformanceStreamMarkerInfoINTEL"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL: + dump_VkPerformanceOverrideInfoINTEL(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPerformanceOverrideInfoINTEL*" : "VkPerformanceOverrideInfoINTEL"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL: + dump_VkPerformanceConfigurationAcquireInfoINTEL(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPerformanceConfigurationAcquireInfoINTEL*" : "VkPerformanceConfigurationAcquireInfoINTEL"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: + dump_VkPhysicalDevicePCIBusInfoPropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePCIBusInfoPropertiesEXT*" : "VkPhysicalDevicePCIBusInfoPropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD: + dump_VkDisplayNativeHdrSurfaceCapabilitiesAMD(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDisplayNativeHdrSurfaceCapabilitiesAMD*" : "VkDisplayNativeHdrSurfaceCapabilitiesAMD"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD: + dump_VkSwapchainDisplayNativeHdrCreateInfoAMD(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSwapchainDisplayNativeHdrCreateInfoAMD*" : "VkSwapchainDisplayNativeHdrCreateInfoAMD"), "pNext", indents, reinterpret_cast(object)); + break; +#if defined(VK_USE_PLATFORM_FUCHSIA) + + case VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA: + dump_VkImagePipeSurfaceCreateInfoFUCHSIA(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImagePipeSurfaceCreateInfoFUCHSIA*" : "VkImagePipeSurfaceCreateInfoFUCHSIA"), "pNext", indents, reinterpret_cast(object)); + break; +#endif // VK_USE_PLATFORM_FUCHSIA +#if defined(VK_USE_PLATFORM_METAL_EXT) + + case VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT: + dump_VkMetalSurfaceCreateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkMetalSurfaceCreateInfoEXT*" : "VkMetalSurfaceCreateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; +#endif // VK_USE_PLATFORM_METAL_EXT + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: + dump_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFragmentDensityMapFeaturesEXT*" : "VkPhysicalDeviceFragmentDensityMapFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT: + dump_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFragmentDensityMapPropertiesEXT*" : "VkPhysicalDeviceFragmentDensityMapPropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: + dump_VkRenderPassFragmentDensityMapCreateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderPassFragmentDensityMapCreateInfoEXT*" : "VkRenderPassFragmentDensityMapCreateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: + dump_VkRenderingFragmentDensityMapAttachmentInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderingFragmentDensityMapAttachmentInfoEXT*" : "VkRenderingFragmentDensityMapAttachmentInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: + dump_VkPhysicalDeviceShaderCoreProperties2AMD(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderCoreProperties2AMD*" : "VkPhysicalDeviceShaderCoreProperties2AMD"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: + dump_VkPhysicalDeviceCoherentMemoryFeaturesAMD(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCoherentMemoryFeaturesAMD*" : "VkPhysicalDeviceCoherentMemoryFeaturesAMD"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: + dump_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*" : "VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT: + dump_VkPhysicalDeviceMemoryBudgetPropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMemoryBudgetPropertiesEXT*" : "VkPhysicalDeviceMemoryBudgetPropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: + dump_VkPhysicalDeviceMemoryPriorityFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMemoryPriorityFeaturesEXT*" : "VkPhysicalDeviceMemoryPriorityFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT: + dump_VkMemoryPriorityAllocateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryPriorityAllocateInfoEXT*" : "VkMemoryPriorityAllocateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: + dump_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*" : "VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: + dump_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*" : "VkPhysicalDeviceBufferDeviceAddressFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: + dump_VkBufferDeviceAddressCreateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkBufferDeviceAddressCreateInfoEXT*" : "VkBufferDeviceAddressCreateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT: + dump_VkValidationFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkValidationFeaturesEXT*" : "VkValidationFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV: + dump_VkCooperativeMatrixPropertiesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCooperativeMatrixPropertiesNV*" : "VkCooperativeMatrixPropertiesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: + dump_VkPhysicalDeviceCooperativeMatrixFeaturesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCooperativeMatrixFeaturesNV*" : "VkPhysicalDeviceCooperativeMatrixFeaturesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV: + dump_VkPhysicalDeviceCooperativeMatrixPropertiesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCooperativeMatrixPropertiesNV*" : "VkPhysicalDeviceCooperativeMatrixPropertiesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: + dump_VkPhysicalDeviceCoverageReductionModeFeaturesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCoverageReductionModeFeaturesNV*" : "VkPhysicalDeviceCoverageReductionModeFeaturesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV: + dump_VkPipelineCoverageReductionStateCreateInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineCoverageReductionStateCreateInfoNV*" : "VkPipelineCoverageReductionStateCreateInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV: + dump_VkFramebufferMixedSamplesCombinationNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkFramebufferMixedSamplesCombinationNV*" : "VkFramebufferMixedSamplesCombinationNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: + dump_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*" : "VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: + dump_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*" : "VkPhysicalDeviceYcbcrImageArraysFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: + dump_VkPhysicalDeviceProvokingVertexFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceProvokingVertexFeaturesEXT*" : "VkPhysicalDeviceProvokingVertexFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: + dump_VkPhysicalDeviceProvokingVertexPropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceProvokingVertexPropertiesEXT*" : "VkPhysicalDeviceProvokingVertexPropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT: + dump_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineRasterizationProvokingVertexStateCreateInfoEXT*" : "VkPipelineRasterizationProvokingVertexStateCreateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; +#if defined(VK_USE_PLATFORM_WIN32_KHR) + + case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT: + dump_VkSurfaceFullScreenExclusiveInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSurfaceFullScreenExclusiveInfoEXT*" : "VkSurfaceFullScreenExclusiveInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT: + dump_VkSurfaceCapabilitiesFullScreenExclusiveEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSurfaceCapabilitiesFullScreenExclusiveEXT*" : "VkSurfaceCapabilitiesFullScreenExclusiveEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT: + dump_VkSurfaceFullScreenExclusiveWin32InfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSurfaceFullScreenExclusiveWin32InfoEXT*" : "VkSurfaceFullScreenExclusiveWin32InfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; +#endif // VK_USE_PLATFORM_WIN32_KHR + + case VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT: + dump_VkHeadlessSurfaceCreateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkHeadlessSurfaceCreateInfoEXT*" : "VkHeadlessSurfaceCreateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: + dump_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*" : "VkPhysicalDeviceShaderAtomicFloatFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: + dump_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*" : "VkPhysicalDeviceExtendedDynamicStateFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT: + dump_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMapMemoryPlacedFeaturesEXT*" : "VkPhysicalDeviceMapMemoryPlacedFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT: + dump_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMapMemoryPlacedPropertiesEXT*" : "VkPhysicalDeviceMapMemoryPlacedPropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT: + dump_VkMemoryMapPlacedInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryMapPlacedInfoEXT*" : "VkMemoryMapPlacedInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: + dump_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*" : "VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: + dump_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*" : "VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: + dump_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*" : "VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV: + dump_VkGraphicsShaderGroupCreateInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkGraphicsShaderGroupCreateInfoNV*" : "VkGraphicsShaderGroupCreateInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV: + dump_VkGraphicsPipelineShaderGroupsCreateInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkGraphicsPipelineShaderGroupsCreateInfoNV*" : "VkGraphicsPipelineShaderGroupsCreateInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV: + dump_VkIndirectCommandsLayoutTokenNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkIndirectCommandsLayoutTokenNV*" : "VkIndirectCommandsLayoutTokenNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV: + dump_VkIndirectCommandsLayoutCreateInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkIndirectCommandsLayoutCreateInfoNV*" : "VkIndirectCommandsLayoutCreateInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV: + dump_VkGeneratedCommandsInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkGeneratedCommandsInfoNV*" : "VkGeneratedCommandsInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV: + dump_VkGeneratedCommandsMemoryRequirementsInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkGeneratedCommandsMemoryRequirementsInfoNV*" : "VkGeneratedCommandsMemoryRequirementsInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: + dump_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceInheritedViewportScissorFeaturesNV*" : "VkPhysicalDeviceInheritedViewportScissorFeaturesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV: + dump_VkCommandBufferInheritanceViewportScissorInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCommandBufferInheritanceViewportScissorInfoNV*" : "VkCommandBufferInheritanceViewportScissorInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: + dump_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*" : "VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: + dump_VkRenderPassTransformBeginInfoQCOM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderPassTransformBeginInfoQCOM*" : "VkRenderPassTransformBeginInfoQCOM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM: + dump_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCommandBufferInheritanceRenderPassTransformInfoQCOM*" : "VkCommandBufferInheritanceRenderPassTransformInfoQCOM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT: + dump_VkPhysicalDeviceDepthBiasControlFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDepthBiasControlFeaturesEXT*" : "VkPhysicalDeviceDepthBiasControlFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT: + dump_VkDepthBiasInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDepthBiasInfoEXT*" : "VkDepthBiasInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT: + dump_VkDepthBiasRepresentationInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDepthBiasRepresentationInfoEXT*" : "VkDepthBiasRepresentationInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT: + dump_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*" : "VkPhysicalDeviceDeviceMemoryReportFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT: + dump_VkDeviceMemoryReportCallbackDataEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceMemoryReportCallbackDataEXT*" : "VkDeviceMemoryReportCallbackDataEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT: + dump_VkDeviceDeviceMemoryReportCreateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceDeviceMemoryReportCreateInfoEXT*" : "VkDeviceDeviceMemoryReportCreateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT: + dump_VkPhysicalDeviceCustomBorderColorPropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCustomBorderColorPropertiesEXT*" : "VkPhysicalDeviceCustomBorderColorPropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: + dump_VkPhysicalDeviceCustomBorderColorFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCustomBorderColorFeaturesEXT*" : "VkPhysicalDeviceCustomBorderColorFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT: + dump_VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT*" : "VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: + dump_VkPhysicalDevicePresentBarrierFeaturesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePresentBarrierFeaturesNV*" : "VkPhysicalDevicePresentBarrierFeaturesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV: + dump_VkSurfaceCapabilitiesPresentBarrierNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSurfaceCapabilitiesPresentBarrierNV*" : "VkSurfaceCapabilitiesPresentBarrierNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV: + dump_VkSwapchainPresentBarrierCreateInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSwapchainPresentBarrierCreateInfoNV*" : "VkSwapchainPresentBarrierCreateInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: + dump_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDiagnosticsConfigFeaturesNV*" : "VkPhysicalDeviceDiagnosticsConfigFeaturesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV: + dump_VkDeviceDiagnosticsConfigCreateInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceDiagnosticsConfigCreateInfoNV*" : "VkDeviceDiagnosticsConfigCreateInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; +#if defined(VK_ENABLE_BETA_EXTENSIONS) + + case VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV: + dump_VkCudaModuleCreateInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCudaModuleCreateInfoNV*" : "VkCudaModuleCreateInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV: + dump_VkCudaFunctionCreateInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCudaFunctionCreateInfoNV*" : "VkCudaFunctionCreateInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV: + dump_VkCudaLaunchInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCudaLaunchInfoNV*" : "VkCudaLaunchInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV: + dump_VkPhysicalDeviceCudaKernelLaunchFeaturesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCudaKernelLaunchFeaturesNV*" : "VkPhysicalDeviceCudaKernelLaunchFeaturesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV: + dump_VkPhysicalDeviceCudaKernelLaunchPropertiesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCudaKernelLaunchPropertiesNV*" : "VkPhysicalDeviceCudaKernelLaunchPropertiesNV"), "pNext", indents, reinterpret_cast(object)); + break; +#endif // VK_ENABLE_BETA_EXTENSIONS + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM: + dump_VkPhysicalDeviceTileShadingFeaturesQCOM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceTileShadingFeaturesQCOM*" : "VkPhysicalDeviceTileShadingFeaturesQCOM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM: + dump_VkPhysicalDeviceTileShadingPropertiesQCOM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceTileShadingPropertiesQCOM*" : "VkPhysicalDeviceTileShadingPropertiesQCOM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM: + dump_VkRenderPassTileShadingCreateInfoQCOM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderPassTileShadingCreateInfoQCOM*" : "VkRenderPassTileShadingCreateInfoQCOM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM: + dump_VkPerTileBeginInfoQCOM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPerTileBeginInfoQCOM*" : "VkPerTileBeginInfoQCOM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM: + dump_VkPerTileEndInfoQCOM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPerTileEndInfoQCOM*" : "VkPerTileEndInfoQCOM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM: + dump_VkDispatchTileInfoQCOM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDispatchTileInfoQCOM*" : "VkDispatchTileInfoQCOM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV: + dump_VkQueryLowLatencySupportNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkQueryLowLatencySupportNV*" : "VkQueryLowLatencySupportNV"), "pNext", indents, reinterpret_cast(object)); + break; +#if defined(VK_USE_PLATFORM_METAL_EXT) + + case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT: + dump_VkExportMetalObjectCreateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkExportMetalObjectCreateInfoEXT*" : "VkExportMetalObjectCreateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT: + dump_VkExportMetalObjectsInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkExportMetalObjectsInfoEXT*" : "VkExportMetalObjectsInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT: + dump_VkExportMetalDeviceInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkExportMetalDeviceInfoEXT*" : "VkExportMetalDeviceInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT: + dump_VkExportMetalCommandQueueInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkExportMetalCommandQueueInfoEXT*" : "VkExportMetalCommandQueueInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT: + dump_VkExportMetalBufferInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkExportMetalBufferInfoEXT*" : "VkExportMetalBufferInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT: + dump_VkImportMetalBufferInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImportMetalBufferInfoEXT*" : "VkImportMetalBufferInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT: + dump_VkExportMetalTextureInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkExportMetalTextureInfoEXT*" : "VkExportMetalTextureInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT: + dump_VkImportMetalTextureInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImportMetalTextureInfoEXT*" : "VkImportMetalTextureInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT: + dump_VkExportMetalIOSurfaceInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkExportMetalIOSurfaceInfoEXT*" : "VkExportMetalIOSurfaceInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT: + dump_VkImportMetalIOSurfaceInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImportMetalIOSurfaceInfoEXT*" : "VkImportMetalIOSurfaceInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT: + dump_VkExportMetalSharedEventInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkExportMetalSharedEventInfoEXT*" : "VkExportMetalSharedEventInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT: + dump_VkImportMetalSharedEventInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImportMetalSharedEventInfoEXT*" : "VkImportMetalSharedEventInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; +#endif // VK_USE_PLATFORM_METAL_EXT + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT: + dump_VkPhysicalDeviceDescriptorBufferPropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDescriptorBufferPropertiesEXT*" : "VkPhysicalDeviceDescriptorBufferPropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT: + dump_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT*" : "VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: + dump_VkPhysicalDeviceDescriptorBufferFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDescriptorBufferFeaturesEXT*" : "VkPhysicalDeviceDescriptorBufferFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT: + dump_VkDescriptorAddressInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDescriptorAddressInfoEXT*" : "VkDescriptorAddressInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT: + dump_VkDescriptorBufferBindingInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDescriptorBufferBindingInfoEXT*" : "VkDescriptorBufferBindingInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT: + dump_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDescriptorBufferBindingPushDescriptorBufferHandleEXT*" : "VkDescriptorBufferBindingPushDescriptorBufferHandleEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT: + dump_VkDescriptorGetInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDescriptorGetInfoEXT*" : "VkDescriptorGetInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: + dump_VkBufferCaptureDescriptorDataInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkBufferCaptureDescriptorDataInfoEXT*" : "VkBufferCaptureDescriptorDataInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: + dump_VkImageCaptureDescriptorDataInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImageCaptureDescriptorDataInfoEXT*" : "VkImageCaptureDescriptorDataInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: + dump_VkImageViewCaptureDescriptorDataInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImageViewCaptureDescriptorDataInfoEXT*" : "VkImageViewCaptureDescriptorDataInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: + dump_VkSamplerCaptureDescriptorDataInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSamplerCaptureDescriptorDataInfoEXT*" : "VkSamplerCaptureDescriptorDataInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: + dump_VkOpaqueCaptureDescriptorDataCreateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkOpaqueCaptureDescriptorDataCreateInfoEXT*" : "VkOpaqueCaptureDescriptorDataCreateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: + dump_VkAccelerationStructureCaptureDescriptorDataInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureCaptureDescriptorDataInfoEXT*" : "VkAccelerationStructureCaptureDescriptorDataInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: + dump_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT*" : "VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: + dump_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT*" : "VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: + dump_VkGraphicsPipelineLibraryCreateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkGraphicsPipelineLibraryCreateInfoEXT*" : "VkGraphicsPipelineLibraryCreateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD: + dump_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD*" : "VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: + dump_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*" : "VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV: + dump_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV*" : "VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV: + dump_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineFragmentShadingRateEnumStateCreateInfoNV*" : "VkPipelineFragmentShadingRateEnumStateCreateInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV: + dump_VkAccelerationStructureGeometryMotionTrianglesDataNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureGeometryMotionTrianglesDataNV*" : "VkAccelerationStructureGeometryMotionTrianglesDataNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV: + dump_VkAccelerationStructureMotionInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureMotionInfoNV*" : "VkAccelerationStructureMotionInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: + dump_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRayTracingMotionBlurFeaturesNV*" : "VkPhysicalDeviceRayTracingMotionBlurFeaturesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: + dump_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT*" : "VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: + dump_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*" : "VkPhysicalDeviceFragmentDensityMap2FeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT: + dump_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFragmentDensityMap2PropertiesEXT*" : "VkPhysicalDeviceFragmentDensityMap2PropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM: + dump_VkCopyCommandTransformInfoQCOM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCopyCommandTransformInfoQCOM*" : "VkCopyCommandTransformInfoQCOM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: + dump_VkPhysicalDeviceImageCompressionControlFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceImageCompressionControlFeaturesEXT*" : "VkPhysicalDeviceImageCompressionControlFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: + dump_VkImageCompressionControlEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImageCompressionControlEXT*" : "VkImageCompressionControlEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT: + dump_VkImageCompressionPropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImageCompressionPropertiesEXT*" : "VkImageCompressionPropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: + dump_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT*" : "VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: + dump_VkPhysicalDevice4444FormatsFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevice4444FormatsFeaturesEXT*" : "VkPhysicalDevice4444FormatsFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT: + dump_VkPhysicalDeviceFaultFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFaultFeaturesEXT*" : "VkPhysicalDeviceFaultFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT: + dump_VkDeviceFaultCountsEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceFaultCountsEXT*" : "VkDeviceFaultCountsEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT: + dump_VkDeviceFaultInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceFaultInfoEXT*" : "VkDeviceFaultInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: + dump_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT*" : "VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: + dump_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT*" : "VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; +#if defined(VK_USE_PLATFORM_DIRECTFB_EXT) + + case VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT: + dump_VkDirectFBSurfaceCreateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDirectFBSurfaceCreateInfoEXT*" : "VkDirectFBSurfaceCreateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; +#endif // VK_USE_PLATFORM_DIRECTFB_EXT + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: + dump_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT*" : "VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT: + dump_VkMutableDescriptorTypeCreateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkMutableDescriptorTypeCreateInfoEXT*" : "VkMutableDescriptorTypeCreateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: + dump_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT*" : "VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT: + dump_VkVertexInputBindingDescription2EXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVertexInputBindingDescription2EXT*" : "VkVertexInputBindingDescription2EXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT: + dump_VkVertexInputAttributeDescription2EXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVertexInputAttributeDescription2EXT*" : "VkVertexInputAttributeDescription2EXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT: + dump_VkPhysicalDeviceDrmPropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDrmPropertiesEXT*" : "VkPhysicalDeviceDrmPropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: + dump_VkPhysicalDeviceAddressBindingReportFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceAddressBindingReportFeaturesEXT*" : "VkPhysicalDeviceAddressBindingReportFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT: + dump_VkDeviceAddressBindingCallbackDataEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceAddressBindingCallbackDataEXT*" : "VkDeviceAddressBindingCallbackDataEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: + dump_VkPhysicalDeviceDepthClipControlFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDepthClipControlFeaturesEXT*" : "VkPhysicalDeviceDepthClipControlFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT: + dump_VkPipelineViewportDepthClipControlCreateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineViewportDepthClipControlCreateInfoEXT*" : "VkPipelineViewportDepthClipControlCreateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: + dump_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT*" : "VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; +#if defined(VK_USE_PLATFORM_FUCHSIA) + + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA: + dump_VkImportMemoryZirconHandleInfoFUCHSIA(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImportMemoryZirconHandleInfoFUCHSIA*" : "VkImportMemoryZirconHandleInfoFUCHSIA"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA: + dump_VkMemoryZirconHandlePropertiesFUCHSIA(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryZirconHandlePropertiesFUCHSIA*" : "VkMemoryZirconHandlePropertiesFUCHSIA"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA: + dump_VkMemoryGetZirconHandleInfoFUCHSIA(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryGetZirconHandleInfoFUCHSIA*" : "VkMemoryGetZirconHandleInfoFUCHSIA"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA: + dump_VkImportSemaphoreZirconHandleInfoFUCHSIA(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImportSemaphoreZirconHandleInfoFUCHSIA*" : "VkImportSemaphoreZirconHandleInfoFUCHSIA"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA: + dump_VkSemaphoreGetZirconHandleInfoFUCHSIA(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSemaphoreGetZirconHandleInfoFUCHSIA*" : "VkSemaphoreGetZirconHandleInfoFUCHSIA"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA: + dump_VkBufferCollectionCreateInfoFUCHSIA(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkBufferCollectionCreateInfoFUCHSIA*" : "VkBufferCollectionCreateInfoFUCHSIA"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA: + dump_VkImportMemoryBufferCollectionFUCHSIA(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImportMemoryBufferCollectionFUCHSIA*" : "VkImportMemoryBufferCollectionFUCHSIA"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA: + dump_VkBufferCollectionImageCreateInfoFUCHSIA(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkBufferCollectionImageCreateInfoFUCHSIA*" : "VkBufferCollectionImageCreateInfoFUCHSIA"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA: + dump_VkBufferCollectionConstraintsInfoFUCHSIA(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkBufferCollectionConstraintsInfoFUCHSIA*" : "VkBufferCollectionConstraintsInfoFUCHSIA"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA: + dump_VkBufferConstraintsInfoFUCHSIA(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkBufferConstraintsInfoFUCHSIA*" : "VkBufferConstraintsInfoFUCHSIA"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA: + dump_VkBufferCollectionBufferCreateInfoFUCHSIA(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkBufferCollectionBufferCreateInfoFUCHSIA*" : "VkBufferCollectionBufferCreateInfoFUCHSIA"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA: + dump_VkSysmemColorSpaceFUCHSIA(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSysmemColorSpaceFUCHSIA*" : "VkSysmemColorSpaceFUCHSIA"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA: + dump_VkBufferCollectionPropertiesFUCHSIA(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkBufferCollectionPropertiesFUCHSIA*" : "VkBufferCollectionPropertiesFUCHSIA"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA: + dump_VkImageFormatConstraintsInfoFUCHSIA(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImageFormatConstraintsInfoFUCHSIA*" : "VkImageFormatConstraintsInfoFUCHSIA"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA: + dump_VkImageConstraintsInfoFUCHSIA(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImageConstraintsInfoFUCHSIA*" : "VkImageConstraintsInfoFUCHSIA"), "pNext", indents, reinterpret_cast(object)); + break; +#endif // VK_USE_PLATFORM_FUCHSIA + + case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI: + dump_VkSubpassShadingPipelineCreateInfoHUAWEI(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSubpassShadingPipelineCreateInfoHUAWEI*" : "VkSubpassShadingPipelineCreateInfoHUAWEI"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: + dump_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceSubpassShadingFeaturesHUAWEI*" : "VkPhysicalDeviceSubpassShadingFeaturesHUAWEI"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI: + dump_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceSubpassShadingPropertiesHUAWEI*" : "VkPhysicalDeviceSubpassShadingPropertiesHUAWEI"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: + dump_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceInvocationMaskFeaturesHUAWEI*" : "VkPhysicalDeviceInvocationMaskFeaturesHUAWEI"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV: + dump_VkMemoryGetRemoteAddressInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryGetRemoteAddressInfoNV*" : "VkMemoryGetRemoteAddressInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV: + dump_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceExternalMemoryRDMAFeaturesNV*" : "VkPhysicalDeviceExternalMemoryRDMAFeaturesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT: + dump_VkPipelinePropertiesIdentifierEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelinePropertiesIdentifierEXT*" : "VkPipelinePropertiesIdentifierEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: + dump_VkPhysicalDevicePipelinePropertiesFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePipelinePropertiesFeaturesEXT*" : "VkPhysicalDevicePipelinePropertiesFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT: + dump_VkPhysicalDeviceFrameBoundaryFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFrameBoundaryFeaturesEXT*" : "VkPhysicalDeviceFrameBoundaryFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT: + dump_VkFrameBoundaryEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkFrameBoundaryEXT*" : "VkFrameBoundaryEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: + dump_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT*" : "VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT: + dump_VkSubpassResolvePerformanceQueryEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSubpassResolvePerformanceQueryEXT*" : "VkSubpassResolvePerformanceQueryEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT: + dump_VkMultisampledRenderToSingleSampledInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkMultisampledRenderToSingleSampledInfoEXT*" : "VkMultisampledRenderToSingleSampledInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: + dump_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*" : "VkPhysicalDeviceExtendedDynamicState2FeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; +#if defined(VK_USE_PLATFORM_SCREEN_QNX) + + case VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX: + dump_VkScreenSurfaceCreateInfoQNX(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkScreenSurfaceCreateInfoQNX*" : "VkScreenSurfaceCreateInfoQNX"), "pNext", indents, reinterpret_cast(object)); + break; +#endif // VK_USE_PLATFORM_SCREEN_QNX + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: + dump_VkPhysicalDeviceColorWriteEnableFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceColorWriteEnableFeaturesEXT*" : "VkPhysicalDeviceColorWriteEnableFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT: + dump_VkPipelineColorWriteCreateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineColorWriteCreateInfoEXT*" : "VkPipelineColorWriteCreateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: + dump_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT*" : "VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE: + dump_VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE*" : "VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE: + dump_VkVideoEncodeRgbConversionCapabilitiesVALVE(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeRgbConversionCapabilitiesVALVE*" : "VkVideoEncodeRgbConversionCapabilitiesVALVE"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE: + dump_VkVideoEncodeProfileRgbConversionInfoVALVE(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeProfileRgbConversionInfoVALVE*" : "VkVideoEncodeProfileRgbConversionInfoVALVE"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE: + dump_VkVideoEncodeSessionRgbConversionCreateInfoVALVE(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkVideoEncodeSessionRgbConversionCreateInfoVALVE*" : "VkVideoEncodeSessionRgbConversionCreateInfoVALVE"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: + dump_VkPhysicalDeviceImageViewMinLodFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceImageViewMinLodFeaturesEXT*" : "VkPhysicalDeviceImageViewMinLodFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT: + dump_VkImageViewMinLodCreateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImageViewMinLodCreateInfoEXT*" : "VkImageViewMinLodCreateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: + dump_VkPhysicalDeviceMultiDrawFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMultiDrawFeaturesEXT*" : "VkPhysicalDeviceMultiDrawFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT: + dump_VkPhysicalDeviceMultiDrawPropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMultiDrawPropertiesEXT*" : "VkPhysicalDeviceMultiDrawPropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: + dump_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceImage2DViewOf3DFeaturesEXT*" : "VkPhysicalDeviceImage2DViewOf3DFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT: + dump_VkPhysicalDeviceShaderTileImageFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderTileImageFeaturesEXT*" : "VkPhysicalDeviceShaderTileImageFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT: + dump_VkPhysicalDeviceShaderTileImagePropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderTileImagePropertiesEXT*" : "VkPhysicalDeviceShaderTileImagePropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT: + dump_VkMicromapBuildInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkMicromapBuildInfoEXT*" : "VkMicromapBuildInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT: + dump_VkMicromapCreateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkMicromapCreateInfoEXT*" : "VkMicromapCreateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT: + dump_VkPhysicalDeviceOpacityMicromapFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceOpacityMicromapFeaturesEXT*" : "VkPhysicalDeviceOpacityMicromapFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT: + dump_VkPhysicalDeviceOpacityMicromapPropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceOpacityMicromapPropertiesEXT*" : "VkPhysicalDeviceOpacityMicromapPropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT: + dump_VkMicromapVersionInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkMicromapVersionInfoEXT*" : "VkMicromapVersionInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT: + dump_VkCopyMicromapToMemoryInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCopyMicromapToMemoryInfoEXT*" : "VkCopyMicromapToMemoryInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT: + dump_VkCopyMemoryToMicromapInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCopyMemoryToMicromapInfoEXT*" : "VkCopyMemoryToMicromapInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT: + dump_VkCopyMicromapInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCopyMicromapInfoEXT*" : "VkCopyMicromapInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT: + dump_VkMicromapBuildSizesInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkMicromapBuildSizesInfoEXT*" : "VkMicromapBuildSizesInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT: + dump_VkAccelerationStructureTrianglesOpacityMicromapEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureTrianglesOpacityMicromapEXT*" : "VkAccelerationStructureTrianglesOpacityMicromapEXT"), "pNext", indents, reinterpret_cast(object)); + break; +#if defined(VK_ENABLE_BETA_EXTENSIONS) + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV: + dump_VkPhysicalDeviceDisplacementMicromapFeaturesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDisplacementMicromapFeaturesNV*" : "VkPhysicalDeviceDisplacementMicromapFeaturesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV: + dump_VkPhysicalDeviceDisplacementMicromapPropertiesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDisplacementMicromapPropertiesNV*" : "VkPhysicalDeviceDisplacementMicromapPropertiesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV: + dump_VkAccelerationStructureTrianglesDisplacementMicromapNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureTrianglesDisplacementMicromapNV*" : "VkAccelerationStructureTrianglesDisplacementMicromapNV"), "pNext", indents, reinterpret_cast(object)); + break; +#endif // VK_ENABLE_BETA_EXTENSIONS + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI: + dump_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI*" : "VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI: + dump_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI*" : "VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI: + dump_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI*" : "VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: + dump_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceBorderColorSwizzleFeaturesEXT*" : "VkPhysicalDeviceBorderColorSwizzleFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT: + dump_VkSamplerBorderColorComponentMappingCreateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSamplerBorderColorComponentMappingCreateInfoEXT*" : "VkSamplerBorderColorComponentMappingCreateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: + dump_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT*" : "VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM: + dump_VkPhysicalDeviceShaderCorePropertiesARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderCorePropertiesARM*" : "VkPhysicalDeviceShaderCorePropertiesARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM: + dump_VkDeviceQueueShaderCoreControlCreateInfoARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceQueueShaderCoreControlCreateInfoARM*" : "VkDeviceQueueShaderCoreControlCreateInfoARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM: + dump_VkPhysicalDeviceSchedulingControlsFeaturesARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceSchedulingControlsFeaturesARM*" : "VkPhysicalDeviceSchedulingControlsFeaturesARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM: + dump_VkPhysicalDeviceSchedulingControlsPropertiesARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceSchedulingControlsPropertiesARM*" : "VkPhysicalDeviceSchedulingControlsPropertiesARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: + dump_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT*" : "VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT: + dump_VkImageViewSlicedCreateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImageViewSlicedCreateInfoEXT*" : "VkImageViewSlicedCreateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: + dump_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE*" : "VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE: + dump_VkDescriptorSetBindingReferenceVALVE(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDescriptorSetBindingReferenceVALVE*" : "VkDescriptorSetBindingReferenceVALVE"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE: + dump_VkDescriptorSetLayoutHostMappingInfoVALVE(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDescriptorSetLayoutHostMappingInfoVALVE*" : "VkDescriptorSetLayoutHostMappingInfoVALVE"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: + dump_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT*" : "VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM: + dump_VkPhysicalDeviceRenderPassStripedFeaturesARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRenderPassStripedFeaturesARM*" : "VkPhysicalDeviceRenderPassStripedFeaturesARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM: + dump_VkPhysicalDeviceRenderPassStripedPropertiesARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRenderPassStripedPropertiesARM*" : "VkPhysicalDeviceRenderPassStripedPropertiesARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM: + dump_VkRenderPassStripeInfoARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderPassStripeInfoARM*" : "VkRenderPassStripeInfoARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM: + dump_VkRenderPassStripeBeginInfoARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderPassStripeBeginInfoARM*" : "VkRenderPassStripeBeginInfoARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM: + dump_VkRenderPassStripeSubmitInfoARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderPassStripeSubmitInfoARM*" : "VkRenderPassStripeSubmitInfoARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT: + dump_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT*" : "VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT: + dump_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT*" : "VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT: + dump_VkRenderPassFragmentDensityMapOffsetEndInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderPassFragmentDensityMapOffsetEndInfoEXT*" : "VkRenderPassFragmentDensityMapOffsetEndInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: + dump_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCopyMemoryIndirectFeaturesNV*" : "VkPhysicalDeviceCopyMemoryIndirectFeaturesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT: + dump_VkPhysicalDeviceMemoryDecompressionFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMemoryDecompressionFeaturesEXT*" : "VkPhysicalDeviceMemoryDecompressionFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT: + dump_VkPhysicalDeviceMemoryDecompressionPropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMemoryDecompressionPropertiesEXT*" : "VkPhysicalDeviceMemoryDecompressionPropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV: + dump_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV*" : "VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV: + dump_VkComputePipelineIndirectBufferInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkComputePipelineIndirectBufferInfoNV*" : "VkComputePipelineIndirectBufferInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV: + dump_VkPipelineIndirectDeviceAddressInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineIndirectDeviceAddressInfoNV*" : "VkPipelineIndirectDeviceAddressInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV: + dump_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV*" : "VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV: + dump_VkAccelerationStructureGeometryLinearSweptSpheresDataNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureGeometryLinearSweptSpheresDataNV*" : "VkAccelerationStructureGeometryLinearSweptSpheresDataNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV: + dump_VkAccelerationStructureGeometrySpheresDataNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureGeometrySpheresDataNV*" : "VkAccelerationStructureGeometrySpheresDataNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: + dump_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceLinearColorAttachmentFeaturesNV*" : "VkPhysicalDeviceLinearColorAttachmentFeaturesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: + dump_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT*" : "VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM: + dump_VkImageViewSampleWeightCreateInfoQCOM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImageViewSampleWeightCreateInfoQCOM*" : "VkImageViewSampleWeightCreateInfoQCOM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: + dump_VkPhysicalDeviceImageProcessingFeaturesQCOM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceImageProcessingFeaturesQCOM*" : "VkPhysicalDeviceImageProcessingFeaturesQCOM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM: + dump_VkPhysicalDeviceImageProcessingPropertiesQCOM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceImageProcessingPropertiesQCOM*" : "VkPhysicalDeviceImageProcessingPropertiesQCOM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT: + dump_VkPhysicalDeviceNestedCommandBufferFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceNestedCommandBufferFeaturesEXT*" : "VkPhysicalDeviceNestedCommandBufferFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT: + dump_VkPhysicalDeviceNestedCommandBufferPropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceNestedCommandBufferPropertiesEXT*" : "VkPhysicalDeviceNestedCommandBufferPropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; +#if defined(VK_USE_PLATFORM_OHOS) + + case VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS: + dump_VkNativeBufferUsageOHOS(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkNativeBufferUsageOHOS*" : "VkNativeBufferUsageOHOS"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS: + dump_VkNativeBufferPropertiesOHOS(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkNativeBufferPropertiesOHOS*" : "VkNativeBufferPropertiesOHOS"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS: + dump_VkNativeBufferFormatPropertiesOHOS(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkNativeBufferFormatPropertiesOHOS*" : "VkNativeBufferFormatPropertiesOHOS"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS: + dump_VkImportNativeBufferInfoOHOS(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImportNativeBufferInfoOHOS*" : "VkImportNativeBufferInfoOHOS"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS: + dump_VkMemoryGetNativeBufferInfoOHOS(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryGetNativeBufferInfoOHOS*" : "VkMemoryGetNativeBufferInfoOHOS"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS: + dump_VkExternalFormatOHOS(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkExternalFormatOHOS*" : "VkExternalFormatOHOS"), "pNext", indents, reinterpret_cast(object)); + break; +#endif // VK_USE_PLATFORM_OHOS + + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT: + dump_VkExternalMemoryAcquireUnmodifiedEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkExternalMemoryAcquireUnmodifiedEXT*" : "VkExternalMemoryAcquireUnmodifiedEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: + dump_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*" : "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT: + dump_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceExtendedDynamicState3PropertiesEXT*" : "VkPhysicalDeviceExtendedDynamicState3PropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: + dump_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT*" : "VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT: + dump_VkRenderPassCreationControlEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderPassCreationControlEXT*" : "VkRenderPassCreationControlEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT: + dump_VkRenderPassCreationFeedbackCreateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderPassCreationFeedbackCreateInfoEXT*" : "VkRenderPassCreationFeedbackCreateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT: + dump_VkRenderPassSubpassFeedbackCreateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderPassSubpassFeedbackCreateInfoEXT*" : "VkRenderPassSubpassFeedbackCreateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG: + dump_VkDirectDriverLoadingInfoLUNARG(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDirectDriverLoadingInfoLUNARG*" : "VkDirectDriverLoadingInfoLUNARG"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG: + dump_VkDirectDriverLoadingListLUNARG(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDirectDriverLoadingListLUNARG*" : "VkDirectDriverLoadingListLUNARG"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM: + dump_VkTensorDescriptionARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkTensorDescriptionARM*" : "VkTensorDescriptionARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM: + dump_VkTensorCreateInfoARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkTensorCreateInfoARM*" : "VkTensorCreateInfoARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM: + dump_VkTensorMemoryRequirementsInfoARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkTensorMemoryRequirementsInfoARM*" : "VkTensorMemoryRequirementsInfoARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM: + dump_VkBindTensorMemoryInfoARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkBindTensorMemoryInfoARM*" : "VkBindTensorMemoryInfoARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM: + dump_VkWriteDescriptorSetTensorARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkWriteDescriptorSetTensorARM*" : "VkWriteDescriptorSetTensorARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM: + dump_VkTensorFormatPropertiesARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkTensorFormatPropertiesARM*" : "VkTensorFormatPropertiesARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM: + dump_VkPhysicalDeviceTensorPropertiesARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceTensorPropertiesARM*" : "VkPhysicalDeviceTensorPropertiesARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM: + dump_VkTensorMemoryBarrierARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkTensorMemoryBarrierARM*" : "VkTensorMemoryBarrierARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM: + dump_VkTensorDependencyInfoARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkTensorDependencyInfoARM*" : "VkTensorDependencyInfoARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM: + dump_VkPhysicalDeviceTensorFeaturesARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceTensorFeaturesARM*" : "VkPhysicalDeviceTensorFeaturesARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM: + dump_VkDeviceTensorMemoryRequirementsARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDeviceTensorMemoryRequirementsARM*" : "VkDeviceTensorMemoryRequirementsARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_TENSOR_COPY_ARM: + dump_VkTensorCopyARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkTensorCopyARM*" : "VkTensorCopyARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_COPY_TENSOR_INFO_ARM: + dump_VkCopyTensorInfoARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCopyTensorInfoARM*" : "VkCopyTensorInfoARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM: + dump_VkMemoryDedicatedAllocateInfoTensorARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryDedicatedAllocateInfoTensorARM*" : "VkMemoryDedicatedAllocateInfoTensorARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM: + dump_VkPhysicalDeviceExternalTensorInfoARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceExternalTensorInfoARM*" : "VkPhysicalDeviceExternalTensorInfoARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_EXTERNAL_TENSOR_PROPERTIES_ARM: + dump_VkExternalTensorPropertiesARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkExternalTensorPropertiesARM*" : "VkExternalTensorPropertiesARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM: + dump_VkExternalMemoryTensorCreateInfoARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkExternalMemoryTensorCreateInfoARM*" : "VkExternalMemoryTensorCreateInfoARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM: + dump_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDescriptorBufferTensorFeaturesARM*" : "VkPhysicalDeviceDescriptorBufferTensorFeaturesARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM: + dump_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDescriptorBufferTensorPropertiesARM*" : "VkPhysicalDeviceDescriptorBufferTensorPropertiesARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM: + dump_VkDescriptorGetTensorInfoARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDescriptorGetTensorInfoARM*" : "VkDescriptorGetTensorInfoARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM: + dump_VkTensorCaptureDescriptorDataInfoARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkTensorCaptureDescriptorDataInfoARM*" : "VkTensorCaptureDescriptorDataInfoARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM: + dump_VkTensorViewCaptureDescriptorDataInfoARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkTensorViewCaptureDescriptorDataInfoARM*" : "VkTensorViewCaptureDescriptorDataInfoARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM: + dump_VkFrameBoundaryTensorsARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkFrameBoundaryTensorsARM*" : "VkFrameBoundaryTensorsARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: + dump_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT*" : "VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT: + dump_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT*" : "VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT: + dump_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineShaderStageModuleIdentifierCreateInfoEXT*" : "VkPipelineShaderStageModuleIdentifierCreateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT: + dump_VkShaderModuleIdentifierEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkShaderModuleIdentifierEXT*" : "VkShaderModuleIdentifierEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: + dump_VkPhysicalDeviceOpticalFlowFeaturesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceOpticalFlowFeaturesNV*" : "VkPhysicalDeviceOpticalFlowFeaturesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV: + dump_VkPhysicalDeviceOpticalFlowPropertiesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceOpticalFlowPropertiesNV*" : "VkPhysicalDeviceOpticalFlowPropertiesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: + dump_VkOpticalFlowImageFormatInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkOpticalFlowImageFormatInfoNV*" : "VkOpticalFlowImageFormatInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV: + dump_VkOpticalFlowImageFormatPropertiesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkOpticalFlowImageFormatPropertiesNV*" : "VkOpticalFlowImageFormatPropertiesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV: + dump_VkOpticalFlowSessionCreateInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkOpticalFlowSessionCreateInfoNV*" : "VkOpticalFlowSessionCreateInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV: + dump_VkOpticalFlowSessionCreatePrivateDataInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkOpticalFlowSessionCreatePrivateDataInfoNV*" : "VkOpticalFlowSessionCreatePrivateDataInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV: + dump_VkOpticalFlowExecuteInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkOpticalFlowExecuteInfoNV*" : "VkOpticalFlowExecuteInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: + dump_VkPhysicalDeviceLegacyDitheringFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceLegacyDitheringFeaturesEXT*" : "VkPhysicalDeviceLegacyDitheringFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; +#if defined(VK_USE_PLATFORM_ANDROID_KHR) + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID: + dump_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceExternalFormatResolveFeaturesANDROID*" : "VkPhysicalDeviceExternalFormatResolveFeaturesANDROID"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID: + dump_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceExternalFormatResolvePropertiesANDROID*" : "VkPhysicalDeviceExternalFormatResolvePropertiesANDROID"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID: + dump_VkAndroidHardwareBufferFormatResolvePropertiesANDROID(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkAndroidHardwareBufferFormatResolvePropertiesANDROID*" : "VkAndroidHardwareBufferFormatResolvePropertiesANDROID"), "pNext", indents, reinterpret_cast(object)); + break; +#endif // VK_USE_PLATFORM_ANDROID_KHR + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD: + dump_VkPhysicalDeviceAntiLagFeaturesAMD(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceAntiLagFeaturesAMD*" : "VkPhysicalDeviceAntiLagFeaturesAMD"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD: + dump_VkAntiLagPresentationInfoAMD(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkAntiLagPresentationInfoAMD*" : "VkAntiLagPresentationInfoAMD"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD: + dump_VkAntiLagDataAMD(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkAntiLagDataAMD*" : "VkAntiLagDataAMD"), "pNext", indents, reinterpret_cast(object)); + break; +#if defined(VK_ENABLE_BETA_EXTENSIONS) + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX: + dump_VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX*" : "VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA_AMDX: + dump_VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX*" : "VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX"), "pNext", indents, reinterpret_cast(object)); + break; +#endif // VK_ENABLE_BETA_EXTENSIONS + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: + dump_VkPhysicalDeviceShaderObjectFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderObjectFeaturesEXT*" : "VkPhysicalDeviceShaderObjectFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT: + dump_VkPhysicalDeviceShaderObjectPropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderObjectPropertiesEXT*" : "VkPhysicalDeviceShaderObjectPropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT: + dump_VkShaderCreateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkShaderCreateInfoEXT*" : "VkShaderCreateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: + dump_VkPhysicalDeviceTilePropertiesFeaturesQCOM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceTilePropertiesFeaturesQCOM*" : "VkPhysicalDeviceTilePropertiesFeaturesQCOM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM: + dump_VkTilePropertiesQCOM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkTilePropertiesQCOM*" : "VkTilePropertiesQCOM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC: + dump_VkPhysicalDeviceAmigoProfilingFeaturesSEC(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceAmigoProfilingFeaturesSEC*" : "VkPhysicalDeviceAmigoProfilingFeaturesSEC"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC: + dump_VkAmigoProfilingSubmitInfoSEC(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkAmigoProfilingSubmitInfoSEC*" : "VkAmigoProfilingSubmitInfoSEC"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: + dump_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM*" : "VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV: + dump_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV*" : "VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: + dump_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV*" : "VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV: + dump_VkPhysicalDeviceCooperativeVectorPropertiesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCooperativeVectorPropertiesNV*" : "VkPhysicalDeviceCooperativeVectorPropertiesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV: + dump_VkPhysicalDeviceCooperativeVectorFeaturesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCooperativeVectorFeaturesNV*" : "VkPhysicalDeviceCooperativeVectorFeaturesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_COOPERATIVE_VECTOR_PROPERTIES_NV: + dump_VkCooperativeVectorPropertiesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCooperativeVectorPropertiesNV*" : "VkCooperativeVectorPropertiesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV: + dump_VkConvertCooperativeVectorMatrixInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkConvertCooperativeVectorMatrixInfoNV*" : "VkConvertCooperativeVectorMatrixInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV: + dump_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV*" : "VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV: + dump_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV*" : "VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT: + dump_VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT*" : "VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT: + dump_VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT*" : "VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT: + dump_VkLayerSettingsCreateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkLayerSettingsCreateInfoEXT*" : "VkLayerSettingsCreateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: + dump_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM*" : "VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM: + dump_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM*" : "VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT: + dump_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT*" : "VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT: + dump_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT*" : "VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV: + dump_VkLatencySleepModeInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkLatencySleepModeInfoNV*" : "VkLatencySleepModeInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV: + dump_VkLatencySleepInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkLatencySleepInfoNV*" : "VkLatencySleepInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV: + dump_VkSetLatencyMarkerInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSetLatencyMarkerInfoNV*" : "VkSetLatencyMarkerInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV: + dump_VkLatencyTimingsFrameReportNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkLatencyTimingsFrameReportNV*" : "VkLatencyTimingsFrameReportNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV: + dump_VkGetLatencyMarkerInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkGetLatencyMarkerInfoNV*" : "VkGetLatencyMarkerInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV: + dump_VkLatencySubmissionPresentIdNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkLatencySubmissionPresentIdNV*" : "VkLatencySubmissionPresentIdNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV: + dump_VkSwapchainLatencyCreateInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSwapchainLatencyCreateInfoNV*" : "VkSwapchainLatencyCreateInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV: + dump_VkOutOfBandQueueTypeInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkOutOfBandQueueTypeInfoNV*" : "VkOutOfBandQueueTypeInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV: + dump_VkLatencySurfaceCapabilitiesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkLatencySurfaceCapabilitiesNV*" : "VkLatencySurfaceCapabilitiesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM: + dump_VkPhysicalDeviceDataGraphFeaturesARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDataGraphFeaturesARM*" : "VkPhysicalDeviceDataGraphFeaturesARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_ARM: + dump_VkDataGraphPipelineConstantARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDataGraphPipelineConstantARM*" : "VkDataGraphPipelineConstantARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_ARM: + dump_VkDataGraphPipelineResourceInfoARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDataGraphPipelineResourceInfoARM*" : "VkDataGraphPipelineResourceInfoARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO_ARM: + dump_VkDataGraphPipelineCompilerControlCreateInfoARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDataGraphPipelineCompilerControlCreateInfoARM*" : "VkDataGraphPipelineCompilerControlCreateInfoARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CREATE_INFO_ARM: + dump_VkDataGraphPipelineCreateInfoARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDataGraphPipelineCreateInfoARM*" : "VkDataGraphPipelineCreateInfoARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM: + dump_VkDataGraphPipelineShaderModuleCreateInfoARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDataGraphPipelineShaderModuleCreateInfoARM*" : "VkDataGraphPipelineShaderModuleCreateInfoARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_CREATE_INFO_ARM: + dump_VkDataGraphPipelineSessionCreateInfoARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDataGraphPipelineSessionCreateInfoARM*" : "VkDataGraphPipelineSessionCreateInfoARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENTS_INFO_ARM: + dump_VkDataGraphPipelineSessionBindPointRequirementsInfoARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDataGraphPipelineSessionBindPointRequirementsInfoARM*" : "VkDataGraphPipelineSessionBindPointRequirementsInfoARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENT_ARM: + dump_VkDataGraphPipelineSessionBindPointRequirementARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDataGraphPipelineSessionBindPointRequirementARM*" : "VkDataGraphPipelineSessionBindPointRequirementARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_MEMORY_REQUIREMENTS_INFO_ARM: + dump_VkDataGraphPipelineSessionMemoryRequirementsInfoARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDataGraphPipelineSessionMemoryRequirementsInfoARM*" : "VkDataGraphPipelineSessionMemoryRequirementsInfoARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_BIND_DATA_GRAPH_PIPELINE_SESSION_MEMORY_INFO_ARM: + dump_VkBindDataGraphPipelineSessionMemoryInfoARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkBindDataGraphPipelineSessionMemoryInfoARM*" : "VkBindDataGraphPipelineSessionMemoryInfoARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_INFO_ARM: + dump_VkDataGraphPipelineInfoARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDataGraphPipelineInfoARM*" : "VkDataGraphPipelineInfoARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_PROPERTY_QUERY_RESULT_ARM: + dump_VkDataGraphPipelinePropertyQueryResultARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDataGraphPipelinePropertyQueryResultARM*" : "VkDataGraphPipelinePropertyQueryResultARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO_ARM: + dump_VkDataGraphPipelineIdentifierCreateInfoARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDataGraphPipelineIdentifierCreateInfoARM*" : "VkDataGraphPipelineIdentifierCreateInfoARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_DISPATCH_INFO_ARM: + dump_VkDataGraphPipelineDispatchInfoARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDataGraphPipelineDispatchInfoARM*" : "VkDataGraphPipelineDispatchInfoARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROPERTIES_ARM: + dump_VkQueueFamilyDataGraphPropertiesARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkQueueFamilyDataGraphPropertiesARM*" : "VkQueueFamilyDataGraphPropertiesARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM: + dump_VkDataGraphProcessingEngineCreateInfoARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDataGraphProcessingEngineCreateInfoARM*" : "VkDataGraphProcessingEngineCreateInfoARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_INFO_ARM: + dump_VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM*" : "VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_PROPERTIES_ARM: + dump_VkQueueFamilyDataGraphProcessingEnginePropertiesARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkQueueFamilyDataGraphProcessingEnginePropertiesARM*" : "VkQueueFamilyDataGraphProcessingEnginePropertiesARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM: + dump_VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM*" : "VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM: + dump_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM*" : "VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM: + dump_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM*" : "VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV: + dump_VkPhysicalDevicePerStageDescriptorSetFeaturesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePerStageDescriptorSetFeaturesNV*" : "VkPhysicalDevicePerStageDescriptorSetFeaturesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM: + dump_VkPhysicalDeviceImageProcessing2FeaturesQCOM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceImageProcessing2FeaturesQCOM*" : "VkPhysicalDeviceImageProcessing2FeaturesQCOM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM: + dump_VkPhysicalDeviceImageProcessing2PropertiesQCOM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceImageProcessing2PropertiesQCOM*" : "VkPhysicalDeviceImageProcessing2PropertiesQCOM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM: + dump_VkSamplerBlockMatchWindowCreateInfoQCOM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSamplerBlockMatchWindowCreateInfoQCOM*" : "VkSamplerBlockMatchWindowCreateInfoQCOM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM: + dump_VkPhysicalDeviceCubicWeightsFeaturesQCOM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCubicWeightsFeaturesQCOM*" : "VkPhysicalDeviceCubicWeightsFeaturesQCOM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM: + dump_VkSamplerCubicWeightsCreateInfoQCOM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSamplerCubicWeightsCreateInfoQCOM*" : "VkSamplerCubicWeightsCreateInfoQCOM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM: + dump_VkBlitImageCubicWeightsInfoQCOM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkBlitImageCubicWeightsInfoQCOM*" : "VkBlitImageCubicWeightsInfoQCOM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM: + dump_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceYcbcrDegammaFeaturesQCOM*" : "VkPhysicalDeviceYcbcrDegammaFeaturesQCOM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM: + dump_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM*" : "VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM: + dump_VkPhysicalDeviceCubicClampFeaturesQCOM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCubicClampFeaturesQCOM*" : "VkPhysicalDeviceCubicClampFeaturesQCOM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: + dump_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT*" : "VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; +#if defined(VK_USE_PLATFORM_SCREEN_QNX) + + case VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX: + dump_VkScreenBufferPropertiesQNX(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkScreenBufferPropertiesQNX*" : "VkScreenBufferPropertiesQNX"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX: + dump_VkScreenBufferFormatPropertiesQNX(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkScreenBufferFormatPropertiesQNX*" : "VkScreenBufferFormatPropertiesQNX"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX: + dump_VkImportScreenBufferInfoQNX(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImportScreenBufferInfoQNX*" : "VkImportScreenBufferInfoQNX"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX: + dump_VkExternalFormatQNX(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkExternalFormatQNX*" : "VkExternalFormatQNX"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX: + dump_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX*" : "VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX"), "pNext", indents, reinterpret_cast(object)); + break; +#endif // VK_USE_PLATFORM_SCREEN_QNX + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT: + dump_VkPhysicalDeviceLayeredDriverPropertiesMSFT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceLayeredDriverPropertiesMSFT*" : "VkPhysicalDeviceLayeredDriverPropertiesMSFT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV: + dump_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV*" : "VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM: + dump_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceTileMemoryHeapFeaturesQCOM*" : "VkPhysicalDeviceTileMemoryHeapFeaturesQCOM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM: + dump_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceTileMemoryHeapPropertiesQCOM*" : "VkPhysicalDeviceTileMemoryHeapPropertiesQCOM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM: + dump_VkTileMemoryRequirementsQCOM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkTileMemoryRequirementsQCOM*" : "VkTileMemoryRequirementsQCOM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM: + dump_VkTileMemoryBindInfoQCOM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkTileMemoryBindInfoQCOM*" : "VkTileMemoryBindInfoQCOM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM: + dump_VkTileMemorySizeInfoQCOM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkTileMemorySizeInfoQCOM*" : "VkTileMemorySizeInfoQCOM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DECOMPRESS_MEMORY_INFO_EXT: + dump_VkDecompressMemoryInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDecompressMemoryInfoEXT*" : "VkDecompressMemoryInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV: + dump_VkDisplaySurfaceStereoCreateInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDisplaySurfaceStereoCreateInfoNV*" : "VkDisplaySurfaceStereoCreateInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV: + dump_VkDisplayModeStereoPropertiesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDisplayModeStereoPropertiesNV*" : "VkDisplayModeStereoPropertiesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV: + dump_VkPhysicalDeviceRawAccessChainsFeaturesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRawAccessChainsFeaturesNV*" : "VkPhysicalDeviceRawAccessChainsFeaturesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV: + dump_VkExternalComputeQueueDeviceCreateInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkExternalComputeQueueDeviceCreateInfoNV*" : "VkExternalComputeQueueDeviceCreateInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV: + dump_VkExternalComputeQueueCreateInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkExternalComputeQueueCreateInfoNV*" : "VkExternalComputeQueueCreateInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV: + dump_VkExternalComputeQueueDataParamsNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkExternalComputeQueueDataParamsNV*" : "VkExternalComputeQueueDataParamsNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV: + dump_VkPhysicalDeviceExternalComputeQueuePropertiesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceExternalComputeQueuePropertiesNV*" : "VkPhysicalDeviceExternalComputeQueuePropertiesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV: + dump_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCommandBufferInheritanceFeaturesNV*" : "VkPhysicalDeviceCommandBufferInheritanceFeaturesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV: + dump_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV*" : "VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT: + dump_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT*" : "VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT: + dump_VkPhysicalDeviceShaderFloat8FeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderFloat8FeaturesEXT*" : "VkPhysicalDeviceShaderFloat8FeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV: + dump_VkPhysicalDeviceRayTracingValidationFeaturesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRayTracingValidationFeaturesNV*" : "VkPhysicalDeviceRayTracingValidationFeaturesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV: + dump_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceClusterAccelerationStructureFeaturesNV*" : "VkPhysicalDeviceClusterAccelerationStructureFeaturesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV: + dump_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceClusterAccelerationStructurePropertiesNV*" : "VkPhysicalDeviceClusterAccelerationStructurePropertiesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV: + dump_VkClusterAccelerationStructureClustersBottomLevelInputNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkClusterAccelerationStructureClustersBottomLevelInputNV*" : "VkClusterAccelerationStructureClustersBottomLevelInputNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV: + dump_VkClusterAccelerationStructureTriangleClusterInputNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkClusterAccelerationStructureTriangleClusterInputNV*" : "VkClusterAccelerationStructureTriangleClusterInputNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV: + dump_VkClusterAccelerationStructureMoveObjectsInputNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkClusterAccelerationStructureMoveObjectsInputNV*" : "VkClusterAccelerationStructureMoveObjectsInputNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV: + dump_VkClusterAccelerationStructureInputInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkClusterAccelerationStructureInputInfoNV*" : "VkClusterAccelerationStructureInputInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV: + dump_VkClusterAccelerationStructureCommandsInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkClusterAccelerationStructureCommandsInfoNV*" : "VkClusterAccelerationStructureCommandsInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR: + dump_VkAccelerationStructureBuildSizesInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureBuildSizesInfoKHR*" : "VkAccelerationStructureBuildSizesInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV: + dump_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV*" : "VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV: + dump_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV*" : "VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV: + dump_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV*" : "VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV: + dump_VkPartitionedAccelerationStructureFlagsNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPartitionedAccelerationStructureFlagsNV*" : "VkPartitionedAccelerationStructureFlagsNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV: + dump_VkWriteDescriptorSetPartitionedAccelerationStructureNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkWriteDescriptorSetPartitionedAccelerationStructureNV*" : "VkWriteDescriptorSetPartitionedAccelerationStructureNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV: + dump_VkPartitionedAccelerationStructureInstancesInputNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPartitionedAccelerationStructureInstancesInputNV*" : "VkPartitionedAccelerationStructureInstancesInputNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV: + dump_VkBuildPartitionedAccelerationStructureInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkBuildPartitionedAccelerationStructureInfoNV*" : "VkBuildPartitionedAccelerationStructureInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT: + dump_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT*" : "VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT: + dump_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT*" : "VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT: + dump_VkGeneratedCommandsMemoryRequirementsInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkGeneratedCommandsMemoryRequirementsInfoEXT*" : "VkGeneratedCommandsMemoryRequirementsInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT: + dump_VkIndirectExecutionSetPipelineInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkIndirectExecutionSetPipelineInfoEXT*" : "VkIndirectExecutionSetPipelineInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT: + dump_VkIndirectExecutionSetShaderLayoutInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkIndirectExecutionSetShaderLayoutInfoEXT*" : "VkIndirectExecutionSetShaderLayoutInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT: + dump_VkIndirectExecutionSetShaderInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkIndirectExecutionSetShaderInfoEXT*" : "VkIndirectExecutionSetShaderInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT: + dump_VkIndirectExecutionSetCreateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkIndirectExecutionSetCreateInfoEXT*" : "VkIndirectExecutionSetCreateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT: + dump_VkGeneratedCommandsInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkGeneratedCommandsInfoEXT*" : "VkGeneratedCommandsInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT: + dump_VkWriteIndirectExecutionSetPipelineEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkWriteIndirectExecutionSetPipelineEXT*" : "VkWriteIndirectExecutionSetPipelineEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT: + dump_VkIndirectCommandsLayoutTokenEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkIndirectCommandsLayoutTokenEXT*" : "VkIndirectCommandsLayoutTokenEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT: + dump_VkIndirectCommandsLayoutCreateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkIndirectCommandsLayoutCreateInfoEXT*" : "VkIndirectCommandsLayoutCreateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT: + dump_VkGeneratedCommandsPipelineInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkGeneratedCommandsPipelineInfoEXT*" : "VkGeneratedCommandsPipelineInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT: + dump_VkGeneratedCommandsShaderInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkGeneratedCommandsShaderInfoEXT*" : "VkGeneratedCommandsShaderInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT: + dump_VkWriteIndirectExecutionSetShaderEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkWriteIndirectExecutionSetShaderEXT*" : "VkWriteIndirectExecutionSetShaderEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA: + dump_VkPhysicalDeviceImageAlignmentControlFeaturesMESA(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceImageAlignmentControlFeaturesMESA*" : "VkPhysicalDeviceImageAlignmentControlFeaturesMESA"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA: + dump_VkPhysicalDeviceImageAlignmentControlPropertiesMESA(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceImageAlignmentControlPropertiesMESA*" : "VkPhysicalDeviceImageAlignmentControlPropertiesMESA"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA: + dump_VkImageAlignmentControlCreateInfoMESA(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImageAlignmentControlCreateInfoMESA*" : "VkImageAlignmentControlCreateInfoMESA"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PUSH_CONSTANT_BANK_INFO_NV: + dump_VkPushConstantBankInfoNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPushConstantBankInfoNV*" : "VkPushConstantBankInfoNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_FEATURES_NV: + dump_VkPhysicalDevicePushConstantBankFeaturesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePushConstantBankFeaturesNV*" : "VkPhysicalDevicePushConstantBankFeaturesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_PROPERTIES_NV: + dump_VkPhysicalDevicePushConstantBankPropertiesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePushConstantBankPropertiesNV*" : "VkPhysicalDevicePushConstantBankPropertiesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_EXT: + dump_VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT*" : "VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT: + dump_VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT*" : "VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT: + dump_VkPhysicalDeviceDepthClampControlFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDepthClampControlFeaturesEXT*" : "VkPhysicalDeviceDepthClampControlFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT: + dump_VkPipelineViewportDepthClampControlCreateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineViewportDepthClampControlCreateInfoEXT*" : "VkPipelineViewportDepthClampControlCreateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; +#if defined(VK_USE_PLATFORM_OHOS) + + case VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS: + dump_VkSurfaceCreateInfoOHOS(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSurfaceCreateInfoOHOS*" : "VkSurfaceCreateInfoOHOS"), "pNext", indents, reinterpret_cast(object)); + break; +#endif // VK_USE_PLATFORM_OHOS + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI: + dump_VkPhysicalDeviceHdrVividFeaturesHUAWEI(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceHdrVividFeaturesHUAWEI*" : "VkPhysicalDeviceHdrVividFeaturesHUAWEI"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI: + dump_VkHdrVividDynamicMetadataHUAWEI(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkHdrVividDynamicMetadataHUAWEI*" : "VkHdrVividDynamicMetadataHUAWEI"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV: + dump_VkCooperativeMatrixFlexibleDimensionsPropertiesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCooperativeMatrixFlexibleDimensionsPropertiesNV*" : "VkCooperativeMatrixFlexibleDimensionsPropertiesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV: + dump_VkPhysicalDeviceCooperativeMatrix2FeaturesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCooperativeMatrix2FeaturesNV*" : "VkPhysicalDeviceCooperativeMatrix2FeaturesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV: + dump_VkPhysicalDeviceCooperativeMatrix2PropertiesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCooperativeMatrix2PropertiesNV*" : "VkPhysicalDeviceCooperativeMatrix2PropertiesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM: + dump_VkPhysicalDevicePipelineOpacityMicromapFeaturesARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePipelineOpacityMicromapFeaturesARM*" : "VkPhysicalDevicePipelineOpacityMicromapFeaturesARM"), "pNext", indents, reinterpret_cast(object)); + break; +#if defined(VK_USE_PLATFORM_METAL_EXT) + + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT: + dump_VkImportMemoryMetalHandleInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkImportMemoryMetalHandleInfoEXT*" : "VkImportMemoryMetalHandleInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_MEMORY_METAL_HANDLE_PROPERTIES_EXT: + dump_VkMemoryMetalHandlePropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryMetalHandlePropertiesEXT*" : "VkMemoryMetalHandlePropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT: + dump_VkMemoryGetMetalHandleInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkMemoryGetMetalHandleInfoEXT*" : "VkMemoryGetMetalHandleInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; +#endif // VK_USE_PLATFORM_METAL_EXT + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_FEATURES_ARM: + dump_VkPhysicalDevicePerformanceCountersByRegionFeaturesARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePerformanceCountersByRegionFeaturesARM*" : "VkPhysicalDevicePerformanceCountersByRegionFeaturesARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_PROPERTIES_ARM: + dump_VkPhysicalDevicePerformanceCountersByRegionPropertiesARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePerformanceCountersByRegionPropertiesARM*" : "VkPhysicalDevicePerformanceCountersByRegionPropertiesARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_ARM: + dump_VkPerformanceCounterARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPerformanceCounterARM*" : "VkPerformanceCounterARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_ARM: + dump_VkPerformanceCounterDescriptionARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPerformanceCounterDescriptionARM*" : "VkPerformanceCounterDescriptionARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_RENDER_PASS_PERFORMANCE_COUNTERS_BY_REGION_BEGIN_INFO_ARM: + dump_VkRenderPassPerformanceCountersByRegionBeginInfoARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkRenderPassPerformanceCountersByRegionBeginInfoARM*" : "VkRenderPassPerformanceCountersByRegionBeginInfoARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT: + dump_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT*" : "VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM: + dump_VkPhysicalDeviceFormatPackFeaturesARM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFormatPackFeaturesARM*" : "VkPhysicalDeviceFormatPackFeaturesARM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE: + dump_VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE*" : "VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE: + dump_VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE*" : "VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE: + dump_VkPipelineFragmentDensityMapLayeredCreateInfoVALVE(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPipelineFragmentDensityMapLayeredCreateInfoVALVE*" : "VkPipelineFragmentDensityMapLayeredCreateInfoVALVE"), "pNext", indents, reinterpret_cast(object)); + break; +#if defined(VK_ENABLE_BETA_EXTENSIONS) + + case VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV: + dump_VkSetPresentConfigNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkSetPresentConfigNV*" : "VkSetPresentConfigNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV: + dump_VkPhysicalDevicePresentMeteringFeaturesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePresentMeteringFeaturesNV*" : "VkPhysicalDevicePresentMeteringFeaturesNV"), "pNext", indents, reinterpret_cast(object)); + break; +#endif // VK_ENABLE_BETA_EXTENSIONS + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT: + dump_VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT*" : "VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT: + dump_VkPhysicalDeviceShader64BitIndexingFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShader64BitIndexingFeaturesEXT*" : "VkPhysicalDeviceShader64BitIndexingFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT: + dump_VkPhysicalDeviceCustomResolveFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceCustomResolveFeaturesEXT*" : "VkPhysicalDeviceCustomResolveFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_BEGIN_CUSTOM_RESOLVE_INFO_EXT: + dump_VkBeginCustomResolveInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkBeginCustomResolveInfoEXT*" : "VkBeginCustomResolveInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_CUSTOM_RESOLVE_CREATE_INFO_EXT: + dump_VkCustomResolveCreateInfoEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCustomResolveCreateInfoEXT*" : "VkCustomResolveCreateInfoEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO_QCOM: + dump_VkDataGraphPipelineBuiltinModelCreateInfoQCOM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkDataGraphPipelineBuiltinModelCreateInfoQCOM*" : "VkDataGraphPipelineBuiltinModelCreateInfoQCOM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM: + dump_VkPhysicalDeviceDataGraphModelFeaturesQCOM(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceDataGraphModelFeaturesQCOM*" : "VkPhysicalDeviceDataGraphModelFeaturesQCOM"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT: + dump_VkPhysicalDeviceShaderLongVectorFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderLongVectorFeaturesEXT*" : "VkPhysicalDeviceShaderLongVectorFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT: + dump_VkPhysicalDeviceShaderLongVectorPropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderLongVectorPropertiesEXT*" : "VkPhysicalDeviceShaderLongVectorPropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC: + dump_VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC*" : "VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT: + dump_VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT*" : "VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_COMPUTE_OCCUPANCY_PRIORITY_PARAMETERS_NV: + dump_VkComputeOccupancyPriorityParametersNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkComputeOccupancyPriorityParametersNV*" : "VkComputeOccupancyPriorityParametersNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES_NV: + dump_VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV*" : "VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT: + dump_VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT*" : "VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR: + dump_VkAccelerationStructureGeometryTrianglesDataKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureGeometryTrianglesDataKHR*" : "VkAccelerationStructureGeometryTrianglesDataKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR: + dump_VkAccelerationStructureGeometryAabbsDataKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureGeometryAabbsDataKHR*" : "VkAccelerationStructureGeometryAabbsDataKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR: + dump_VkAccelerationStructureGeometryInstancesDataKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureGeometryInstancesDataKHR*" : "VkAccelerationStructureGeometryInstancesDataKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR: + dump_VkAccelerationStructureGeometryKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureGeometryKHR*" : "VkAccelerationStructureGeometryKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR: + dump_VkAccelerationStructureBuildGeometryInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureBuildGeometryInfoKHR*" : "VkAccelerationStructureBuildGeometryInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR: + dump_VkAccelerationStructureCreateInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureCreateInfoKHR*" : "VkAccelerationStructureCreateInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: + dump_VkWriteDescriptorSetAccelerationStructureKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkWriteDescriptorSetAccelerationStructureKHR*" : "VkWriteDescriptorSetAccelerationStructureKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: + dump_VkPhysicalDeviceAccelerationStructureFeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceAccelerationStructureFeaturesKHR*" : "VkPhysicalDeviceAccelerationStructureFeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR: + dump_VkPhysicalDeviceAccelerationStructurePropertiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceAccelerationStructurePropertiesKHR*" : "VkPhysicalDeviceAccelerationStructurePropertiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR: + dump_VkAccelerationStructureDeviceAddressInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureDeviceAddressInfoKHR*" : "VkAccelerationStructureDeviceAddressInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR: + dump_VkAccelerationStructureVersionInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkAccelerationStructureVersionInfoKHR*" : "VkAccelerationStructureVersionInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR: + dump_VkCopyAccelerationStructureToMemoryInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCopyAccelerationStructureToMemoryInfoKHR*" : "VkCopyAccelerationStructureToMemoryInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR: + dump_VkCopyMemoryToAccelerationStructureInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCopyMemoryToAccelerationStructureInfoKHR*" : "VkCopyMemoryToAccelerationStructureInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR: + dump_VkCopyAccelerationStructureInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkCopyAccelerationStructureInfoKHR*" : "VkCopyAccelerationStructureInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR: + dump_VkRayTracingShaderGroupCreateInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkRayTracingShaderGroupCreateInfoKHR*" : "VkRayTracingShaderGroupCreateInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR: + dump_VkRayTracingPipelineInterfaceCreateInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkRayTracingPipelineInterfaceCreateInfoKHR*" : "VkRayTracingPipelineInterfaceCreateInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR: + dump_VkRayTracingPipelineCreateInfoKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkRayTracingPipelineCreateInfoKHR*" : "VkRayTracingPipelineCreateInfoKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: + dump_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRayTracingPipelineFeaturesKHR*" : "VkPhysicalDeviceRayTracingPipelineFeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: + dump_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRayTracingPipelinePropertiesKHR*" : "VkPhysicalDeviceRayTracingPipelinePropertiesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: + dump_VkPhysicalDeviceRayQueryFeaturesKHR(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceRayQueryFeaturesKHR*" : "VkPhysicalDeviceRayQueryFeaturesKHR"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT: + dump_VkPhysicalDeviceMeshShaderFeaturesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMeshShaderFeaturesEXT*" : "VkPhysicalDeviceMeshShaderFeaturesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT: + dump_VkPhysicalDeviceMeshShaderPropertiesEXT(*reinterpret_cast(object), settings, (Format == ApiDumpFormat::Json ? "VkPhysicalDeviceMeshShaderPropertiesEXT*" : "VkPhysicalDeviceMeshShaderPropertiesEXT"), "pNext", indents, reinterpret_cast(object)); + break; + + case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO: // 47 + case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO: // 48 + if (base_struct.pNext != nullptr) { + dump_pNext_trampoline(reinterpret_cast(base_struct.pNext), settings, type_name, var_name, indents); + } else { + dump_nullptr(settings, "const void*", "pNext", indents); + } + break; + default: + dump_start(settings, OutputConstruct::value, "const void*", "pNext", indents); + dump_value(settings, "UNKNOWN (", (int64_t)(base_struct.sType), ")"); + dump_end(settings, OutputConstruct::value, indents); + } +} + +//========================== Function Helpers ===============================// + +template +void dump_params_vkCreateInstance(ApiDumpInstance& dump_inst, const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_pointer(pCreateInfo, settings, "const VkInstanceCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkInstanceCreateInfo); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pInstance, settings, "VkInstance*", "pInstance", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkInstance); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyInstance(ApiDumpInstance& dump_inst, VkInstance instance, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkInstance(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkEnumeratePhysicalDevices(ApiDumpInstance& dump_inst, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkInstance(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pPhysicalDeviceCount, settings, "uint32_t*", "pPhysicalDeviceCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pPhysicalDevices, *pPhysicalDeviceCount, settings, "VkPhysicalDevice*", "pPhysicalDevices", "VkPhysicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDevice); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceFeatures(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pFeatures, settings, "VkPhysicalDeviceFeatures*", "pFeatures", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceFeatures); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceFormatProperties(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkFormat(format, settings, "VkFormat", "format", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pFormatProperties, settings, "VkFormatProperties*", "pFormatProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkFormatProperties); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceImageFormatProperties(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkFormat(format, settings, "VkFormat", "format", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImageType(type, settings, "VkImageType", "type", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImageTiling(tiling, settings, "VkImageTiling", "tiling", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImageUsageFlags(usage, settings, "VkImageUsageFlags", "usage", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImageCreateFlags(flags, settings, "VkImageCreateFlags", "flags", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pImageFormatProperties, settings, "VkImageFormatProperties*", "pImageFormatProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageFormatProperties); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceProperties(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pProperties, settings, "VkPhysicalDeviceProperties*", "pProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceProperties); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceQueueFamilyProperties(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pQueueFamilyPropertyCount, settings, "uint32_t*", "pQueueFamilyPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pQueueFamilyProperties, *pQueueFamilyPropertyCount, settings, "VkQueueFamilyProperties*", "pQueueFamilyProperties", "VkQueueFamilyProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkQueueFamilyProperties); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceMemoryProperties(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pMemoryProperties, settings, "VkPhysicalDeviceMemoryProperties*", "pMemoryProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceMemoryProperties); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateDevice(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkDeviceCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceCreateInfo); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pDevice, settings, "VkDevice*", "pDevice", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDevice); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyDevice(ApiDumpInstance& dump_inst, VkDevice device, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkEnumerateInstanceExtensionProperties(ApiDumpInstance& dump_inst, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_char(pLayerName, settings, "const char*", "pLayerName", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pPropertyCount, settings, "uint32_t*", "pPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pProperties, *pPropertyCount, settings, "VkExtensionProperties*", "pProperties", "VkExtensionProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkExtensionProperties); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkEnumerateDeviceExtensionProperties(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_char(pLayerName, settings, "const char*", "pLayerName", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pPropertyCount, settings, "uint32_t*", "pPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pProperties, *pPropertyCount, settings, "VkExtensionProperties*", "pProperties", "VkExtensionProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkExtensionProperties); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkEnumerateInstanceLayerProperties(ApiDumpInstance& dump_inst, uint32_t* pPropertyCount, VkLayerProperties* pProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_pointer(pPropertyCount, settings, "uint32_t*", "pPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pProperties, *pPropertyCount, settings, "VkLayerProperties*", "pProperties", "VkLayerProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkLayerProperties); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkEnumerateDeviceLayerProperties(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pPropertyCount, settings, "uint32_t*", "pPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pProperties, *pPropertyCount, settings, "VkLayerProperties*", "pProperties", "VkLayerProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkLayerProperties); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetDeviceQueue(ApiDumpInstance& dump_inst, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(queueIndex, settings, "uint32_t", "queueIndex", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pQueue, settings, "VkQueue*", "pQueue", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkQueue); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkQueueSubmit(ApiDumpInstance& dump_inst, VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkQueue(queue, settings, "VkQueue", "queue", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(submitCount, settings, "uint32_t", "submitCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pSubmits, submitCount, settings, "const VkSubmitInfo*", "pSubmits", "const VkSubmitInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSubmitInfo); + dump_separate_members(settings); + dump_VkFence(fence, settings, "VkFence", "fence", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkQueueWaitIdle(ApiDumpInstance& dump_inst, VkQueue queue) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkQueue(queue, settings, "VkQueue", "queue", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDeviceWaitIdle(ApiDumpInstance& dump_inst, VkDevice device) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkAllocateMemory(ApiDumpInstance& dump_inst, VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocateInfo, settings, "const VkMemoryAllocateInfo*", "pAllocateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryAllocateInfo); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pMemory, settings, "VkDeviceMemory*", "pMemory", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceMemory); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkFreeMemory(ApiDumpInstance& dump_inst, VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDeviceMemory(memory, settings, "VkDeviceMemory", "memory", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkMapMemory(ApiDumpInstance& dump_inst, VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDeviceMemory(memory, settings, "VkDeviceMemory", "memory", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(offset, settings, "VkDeviceSize", "offset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(size, settings, "VkDeviceSize", "size", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkMemoryMapFlags(flags, settings, "VkMemoryMapFlags", "flags", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(ppData, settings, "void**", "ppData", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkUnmapMemory(ApiDumpInstance& dump_inst, VkDevice device, VkDeviceMemory memory) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDeviceMemory(memory, settings, "VkDeviceMemory", "memory", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkFlushMappedMemoryRanges(ApiDumpInstance& dump_inst, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(memoryRangeCount, settings, "uint32_t", "memoryRangeCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pMemoryRanges, memoryRangeCount, settings, "const VkMappedMemoryRange*", "pMemoryRanges", "const VkMappedMemoryRange", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMappedMemoryRange); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkInvalidateMappedMemoryRanges(ApiDumpInstance& dump_inst, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(memoryRangeCount, settings, "uint32_t", "memoryRangeCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pMemoryRanges, memoryRangeCount, settings, "const VkMappedMemoryRange*", "pMemoryRanges", "const VkMappedMemoryRange", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMappedMemoryRange); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetDeviceMemoryCommitment(ApiDumpInstance& dump_inst, VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDeviceMemory(memory, settings, "VkDeviceMemory", "memory", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCommittedMemoryInBytes, settings, "VkDeviceSize*", "pCommittedMemoryInBytes", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkBindBufferMemory(ApiDumpInstance& dump_inst, VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(buffer, settings, "VkBuffer", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDeviceMemory(memory, settings, "VkDeviceMemory", "memory", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(memoryOffset, settings, "VkDeviceSize", "memoryOffset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkBindImageMemory(ApiDumpInstance& dump_inst, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImage(image, settings, "VkImage", "image", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDeviceMemory(memory, settings, "VkDeviceMemory", "memory", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(memoryOffset, settings, "VkDeviceSize", "memoryOffset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetBufferMemoryRequirements(ApiDumpInstance& dump_inst, VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(buffer, settings, "VkBuffer", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pMemoryRequirements, settings, "VkMemoryRequirements*", "pMemoryRequirements", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetImageMemoryRequirements(ApiDumpInstance& dump_inst, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImage(image, settings, "VkImage", "image", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pMemoryRequirements, settings, "VkMemoryRequirements*", "pMemoryRequirements", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetImageSparseMemoryRequirements(ApiDumpInstance& dump_inst, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImage(image, settings, "VkImage", "image", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pSparseMemoryRequirementCount, settings, "uint32_t*", "pSparseMemoryRequirementCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pSparseMemoryRequirements, *pSparseMemoryRequirementCount, settings, "VkSparseImageMemoryRequirements*", "pSparseMemoryRequirements", "VkSparseImageMemoryRequirements", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSparseImageMemoryRequirements); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceSparseImageFormatProperties(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkFormat(format, settings, "VkFormat", "format", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImageType(type, settings, "VkImageType", "type", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkSampleCountFlagBits(samples, settings, "VkSampleCountFlagBits", "samples", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImageUsageFlags(usage, settings, "VkImageUsageFlags", "usage", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImageTiling(tiling, settings, "VkImageTiling", "tiling", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pPropertyCount, settings, "uint32_t*", "pPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pProperties, *pPropertyCount, settings, "VkSparseImageFormatProperties*", "pProperties", "VkSparseImageFormatProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSparseImageFormatProperties); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkQueueBindSparse(ApiDumpInstance& dump_inst, VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkQueue(queue, settings, "VkQueue", "queue", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(bindInfoCount, settings, "uint32_t", "bindInfoCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pBindInfo, bindInfoCount, settings, "const VkBindSparseInfo*", "pBindInfo", "const VkBindSparseInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBindSparseInfo); + dump_separate_members(settings); + dump_VkFence(fence, settings, "VkFence", "fence", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateFence(ApiDumpInstance& dump_inst, VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkFenceCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkFenceCreateInfo); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pFence, settings, "VkFence*", "pFence", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkFence); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyFence(ApiDumpInstance& dump_inst, VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkFence(fence, settings, "VkFence", "fence", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkResetFences(ApiDumpInstance& dump_inst, VkDevice device, uint32_t fenceCount, const VkFence* pFences) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(fenceCount, settings, "uint32_t", "fenceCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pFences, fenceCount, settings, "const VkFence*", "pFences", "const VkFence", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkFence); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetFenceStatus(ApiDumpInstance& dump_inst, VkDevice device, VkFence fence) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkFence(fence, settings, "VkFence", "fence", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkWaitForFences(ApiDumpInstance& dump_inst, VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(fenceCount, settings, "uint32_t", "fenceCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pFences, fenceCount, settings, "const VkFence*", "pFences", "const VkFence", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkFence); + dump_separate_members(settings); + dump_type(waitAll, settings, "VkBool32", "waitAll", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(timeout, settings, "uint64_t", "timeout", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateSemaphore(ApiDumpInstance& dump_inst, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkSemaphoreCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSemaphoreCreateInfo); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pSemaphore, settings, "VkSemaphore*", "pSemaphore", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSemaphore); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroySemaphore(ApiDumpInstance& dump_inst, VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkSemaphore(semaphore, settings, "VkSemaphore", "semaphore", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateQueryPool(ApiDumpInstance& dump_inst, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkQueryPoolCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkQueryPoolCreateInfo); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pQueryPool, settings, "VkQueryPool*", "pQueryPool", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkQueryPool); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyQueryPool(ApiDumpInstance& dump_inst, VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkQueryPool(queryPool, settings, "VkQueryPool", "queryPool", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetQueryPoolResults(ApiDumpInstance& dump_inst, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkQueryPool(queryPool, settings, "VkQueryPool", "queryPool", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(firstQuery, settings, "uint32_t", "firstQuery", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(queryCount, settings, "uint32_t", "queryCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(dataSize, settings, "size_t", "dataSize", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(pData, settings, "void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(stride, settings, "VkDeviceSize", "stride", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkQueryResultFlags(flags, settings, "VkQueryResultFlags", "flags", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateBuffer(ApiDumpInstance& dump_inst, VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkBufferCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferCreateInfo); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pBuffer, settings, "VkBuffer*", "pBuffer", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBuffer); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyBuffer(ApiDumpInstance& dump_inst, VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(buffer, settings, "VkBuffer", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateImage(ApiDumpInstance& dump_inst, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkImageCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageCreateInfo); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pImage, settings, "VkImage*", "pImage", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImage); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyImage(ApiDumpInstance& dump_inst, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImage(image, settings, "VkImage", "image", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetImageSubresourceLayout(ApiDumpInstance& dump_inst, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImage(image, settings, "VkImage", "image", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pSubresource, settings, "const VkImageSubresource*", "pSubresource", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageSubresource); + dump_separate_members(settings); + dump_pointer(pLayout, settings, "VkSubresourceLayout*", "pLayout", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSubresourceLayout); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateImageView(ApiDumpInstance& dump_inst, VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkImageViewCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageViewCreateInfo); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pView, settings, "VkImageView*", "pView", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageView); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyImageView(ApiDumpInstance& dump_inst, VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImageView(imageView, settings, "VkImageView", "imageView", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateCommandPool(ApiDumpInstance& dump_inst, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkCommandPoolCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCommandPoolCreateInfo); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pCommandPool, settings, "VkCommandPool*", "pCommandPool", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCommandPool); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyCommandPool(ApiDumpInstance& dump_inst, VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkCommandPool(commandPool, settings, "VkCommandPool", "commandPool", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkResetCommandPool(ApiDumpInstance& dump_inst, VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkCommandPool(commandPool, settings, "VkCommandPool", "commandPool", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkCommandPoolResetFlags(flags, settings, "VkCommandPoolResetFlags", "flags", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkAllocateCommandBuffers(ApiDumpInstance& dump_inst, VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocateInfo, settings, "const VkCommandBufferAllocateInfo*", "pAllocateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCommandBufferAllocateInfo); + dump_separate_members(settings); + dump_pointer_array(pCommandBuffers, pAllocateInfo->commandBufferCount, settings, "VkCommandBuffer*", "pCommandBuffers", "VkCommandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCommandBuffer); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkFreeCommandBuffers(ApiDumpInstance& dump_inst, VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkCommandPool(commandPool, settings, "VkCommandPool", "commandPool", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(commandBufferCount, settings, "uint32_t", "commandBufferCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pCommandBuffers, commandBufferCount, settings, "const VkCommandBuffer*", "pCommandBuffers", "const VkCommandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCommandBuffer); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkBeginCommandBuffer(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + ApiDumpInstance::current().setCmdBuffer(commandBuffer); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pBeginInfo, settings, "const VkCommandBufferBeginInfo*", "pBeginInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCommandBufferBeginInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkEndCommandBuffer(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkResetCommandBuffer(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkCommandBufferResetFlags(flags, settings, "VkCommandBufferResetFlags", "flags", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdCopyBuffer(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(srcBuffer, settings, "VkBuffer", "srcBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(dstBuffer, settings, "VkBuffer", "dstBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(regionCount, settings, "uint32_t", "regionCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pRegions, regionCount, settings, "const VkBufferCopy*", "pRegions", "const VkBufferCopy", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferCopy); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdCopyImage(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImage(srcImage, settings, "VkImage", "srcImage", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(srcImageLayout, settings, "VkImageLayout", "srcImageLayout", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImage(dstImage, settings, "VkImage", "dstImage", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(dstImageLayout, settings, "VkImageLayout", "dstImageLayout", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(regionCount, settings, "uint32_t", "regionCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pRegions, regionCount, settings, "const VkImageCopy*", "pRegions", "const VkImageCopy", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageCopy); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdCopyBufferToImage(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(srcBuffer, settings, "VkBuffer", "srcBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImage(dstImage, settings, "VkImage", "dstImage", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(dstImageLayout, settings, "VkImageLayout", "dstImageLayout", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(regionCount, settings, "uint32_t", "regionCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pRegions, regionCount, settings, "const VkBufferImageCopy*", "pRegions", "const VkBufferImageCopy", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferImageCopy); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdCopyImageToBuffer(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImage(srcImage, settings, "VkImage", "srcImage", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(srcImageLayout, settings, "VkImageLayout", "srcImageLayout", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(dstBuffer, settings, "VkBuffer", "dstBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(regionCount, settings, "uint32_t", "regionCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pRegions, regionCount, settings, "const VkBufferImageCopy*", "pRegions", "const VkBufferImageCopy", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferImageCopy); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdUpdateBuffer(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(dstBuffer, settings, "VkBuffer", "dstBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(dstOffset, settings, "VkDeviceSize", "dstOffset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(dataSize, settings, "VkDeviceSize", "dataSize", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(pData, settings, "const void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdFillBuffer(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(dstBuffer, settings, "VkBuffer", "dstBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(dstOffset, settings, "VkDeviceSize", "dstOffset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(size, settings, "VkDeviceSize", "size", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(data, settings, "uint32_t", "data", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdPipelineBarrier(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipelineStageFlags(srcStageMask, settings, "VkPipelineStageFlags", "srcStageMask", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipelineStageFlags(dstStageMask, settings, "VkPipelineStageFlags", "dstStageMask", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDependencyFlags(dependencyFlags, settings, "VkDependencyFlags", "dependencyFlags", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(memoryBarrierCount, settings, "uint32_t", "memoryBarrierCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pMemoryBarriers, memoryBarrierCount, settings, "const VkMemoryBarrier*", "pMemoryBarriers", "const VkMemoryBarrier", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryBarrier); + dump_separate_members(settings); + dump_type(bufferMemoryBarrierCount, settings, "uint32_t", "bufferMemoryBarrierCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pBufferMemoryBarriers, bufferMemoryBarrierCount, settings, "const VkBufferMemoryBarrier*", "pBufferMemoryBarriers", "const VkBufferMemoryBarrier", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferMemoryBarrier); + dump_separate_members(settings); + dump_type(imageMemoryBarrierCount, settings, "uint32_t", "imageMemoryBarrierCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pImageMemoryBarriers, imageMemoryBarrierCount, settings, "const VkImageMemoryBarrier*", "pImageMemoryBarriers", "const VkImageMemoryBarrier", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageMemoryBarrier); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdBeginQuery(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkQueryPool(queryPool, settings, "VkQueryPool", "queryPool", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(query, settings, "uint32_t", "query", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkQueryControlFlags(flags, settings, "VkQueryControlFlags", "flags", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdEndQuery(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkQueryPool(queryPool, settings, "VkQueryPool", "queryPool", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(query, settings, "uint32_t", "query", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdResetQueryPool(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkQueryPool(queryPool, settings, "VkQueryPool", "queryPool", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(firstQuery, settings, "uint32_t", "firstQuery", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(queryCount, settings, "uint32_t", "queryCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdWriteTimestamp(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipelineStageFlagBits(pipelineStage, settings, "VkPipelineStageFlagBits", "pipelineStage", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkQueryPool(queryPool, settings, "VkQueryPool", "queryPool", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(query, settings, "uint32_t", "query", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdCopyQueryPoolResults(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkQueryPool(queryPool, settings, "VkQueryPool", "queryPool", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(firstQuery, settings, "uint32_t", "firstQuery", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(queryCount, settings, "uint32_t", "queryCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(dstBuffer, settings, "VkBuffer", "dstBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(dstOffset, settings, "VkDeviceSize", "dstOffset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(stride, settings, "VkDeviceSize", "stride", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkQueryResultFlags(flags, settings, "VkQueryResultFlags", "flags", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdExecuteCommands(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(commandBufferCount, settings, "uint32_t", "commandBufferCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pCommandBuffers, commandBufferCount, settings, "const VkCommandBuffer*", "pCommandBuffers", "const VkCommandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCommandBuffer); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateEvent(ApiDumpInstance& dump_inst, VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkEventCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkEventCreateInfo); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pEvent, settings, "VkEvent*", "pEvent", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkEvent); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyEvent(ApiDumpInstance& dump_inst, VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkEvent(event, settings, "VkEvent", "event", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetEventStatus(ApiDumpInstance& dump_inst, VkDevice device, VkEvent event) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkEvent(event, settings, "VkEvent", "event", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkSetEvent(ApiDumpInstance& dump_inst, VkDevice device, VkEvent event) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkEvent(event, settings, "VkEvent", "event", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkResetEvent(ApiDumpInstance& dump_inst, VkDevice device, VkEvent event) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkEvent(event, settings, "VkEvent", "event", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateBufferView(ApiDumpInstance& dump_inst, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkBufferViewCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferViewCreateInfo); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pView, settings, "VkBufferView*", "pView", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferView); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyBufferView(ApiDumpInstance& dump_inst, VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBufferView(bufferView, settings, "VkBufferView", "bufferView", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateShaderModule(ApiDumpInstance& dump_inst, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkShaderModuleCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkShaderModuleCreateInfo); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pShaderModule, settings, "VkShaderModule*", "pShaderModule", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkShaderModule); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyShaderModule(ApiDumpInstance& dump_inst, VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkShaderModule(shaderModule, settings, "VkShaderModule", "shaderModule", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreatePipelineCache(ApiDumpInstance& dump_inst, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkPipelineCacheCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineCacheCreateInfo); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pPipelineCache, settings, "VkPipelineCache*", "pPipelineCache", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineCache); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyPipelineCache(ApiDumpInstance& dump_inst, VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipelineCache(pipelineCache, settings, "VkPipelineCache", "pipelineCache", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPipelineCacheData(ApiDumpInstance& dump_inst, VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipelineCache(pipelineCache, settings, "VkPipelineCache", "pipelineCache", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pDataSize, settings, "size_t*", "pDataSize", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_type(pData, settings, "void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkMergePipelineCaches(ApiDumpInstance& dump_inst, VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipelineCache(dstCache, settings, "VkPipelineCache", "dstCache", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(srcCacheCount, settings, "uint32_t", "srcCacheCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pSrcCaches, srcCacheCount, settings, "const VkPipelineCache*", "pSrcCaches", "const VkPipelineCache", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineCache); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateComputePipelines(ApiDumpInstance& dump_inst, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipelineCache(pipelineCache, settings, "VkPipelineCache", "pipelineCache", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(createInfoCount, settings, "uint32_t", "createInfoCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pCreateInfos, createInfoCount, settings, "const VkComputePipelineCreateInfo*", "pCreateInfos", "const VkComputePipelineCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkComputePipelineCreateInfo); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer_array(pPipelines, createInfoCount, settings, "VkPipeline*", "pPipelines", "VkPipeline", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipeline); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyPipeline(ApiDumpInstance& dump_inst, VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipeline(pipeline, settings, "VkPipeline", "pipeline", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreatePipelineLayout(ApiDumpInstance& dump_inst, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkPipelineLayoutCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineLayoutCreateInfo); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pPipelineLayout, settings, "VkPipelineLayout*", "pPipelineLayout", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineLayout); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyPipelineLayout(ApiDumpInstance& dump_inst, VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipelineLayout(pipelineLayout, settings, "VkPipelineLayout", "pipelineLayout", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateSampler(ApiDumpInstance& dump_inst, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkSamplerCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSamplerCreateInfo); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pSampler, settings, "VkSampler*", "pSampler", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSampler); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroySampler(ApiDumpInstance& dump_inst, VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkSampler(sampler, settings, "VkSampler", "sampler", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateDescriptorSetLayout(ApiDumpInstance& dump_inst, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkDescriptorSetLayoutCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorSetLayoutCreateInfo); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pSetLayout, settings, "VkDescriptorSetLayout*", "pSetLayout", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorSetLayout); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyDescriptorSetLayout(ApiDumpInstance& dump_inst, VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDescriptorSetLayout(descriptorSetLayout, settings, "VkDescriptorSetLayout", "descriptorSetLayout", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateDescriptorPool(ApiDumpInstance& dump_inst, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkDescriptorPoolCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorPoolCreateInfo); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pDescriptorPool, settings, "VkDescriptorPool*", "pDescriptorPool", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorPool); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyDescriptorPool(ApiDumpInstance& dump_inst, VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDescriptorPool(descriptorPool, settings, "VkDescriptorPool", "descriptorPool", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkResetDescriptorPool(ApiDumpInstance& dump_inst, VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDescriptorPool(descriptorPool, settings, "VkDescriptorPool", "descriptorPool", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDescriptorPoolResetFlags(flags, settings, "VkDescriptorPoolResetFlags", "flags", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkAllocateDescriptorSets(ApiDumpInstance& dump_inst, VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocateInfo, settings, "const VkDescriptorSetAllocateInfo*", "pAllocateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorSetAllocateInfo); + dump_separate_members(settings); + dump_pointer_array(pDescriptorSets, pAllocateInfo->descriptorSetCount, settings, "VkDescriptorSet*", "pDescriptorSets", "VkDescriptorSet", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorSet); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkFreeDescriptorSets(ApiDumpInstance& dump_inst, VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDescriptorPool(descriptorPool, settings, "VkDescriptorPool", "descriptorPool", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(descriptorSetCount, settings, "uint32_t", "descriptorSetCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pDescriptorSets, descriptorSetCount, settings, "const VkDescriptorSet*", "pDescriptorSets", "const VkDescriptorSet", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorSet); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkUpdateDescriptorSets(ApiDumpInstance& dump_inst, VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(descriptorWriteCount, settings, "uint32_t", "descriptorWriteCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pDescriptorWrites, descriptorWriteCount, settings, "const VkWriteDescriptorSet*", "pDescriptorWrites", "const VkWriteDescriptorSet", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkWriteDescriptorSet); + dump_separate_members(settings); + dump_type(descriptorCopyCount, settings, "uint32_t", "descriptorCopyCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pDescriptorCopies, descriptorCopyCount, settings, "const VkCopyDescriptorSet*", "pDescriptorCopies", "const VkCopyDescriptorSet", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyDescriptorSet); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdBindPipeline(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipelineBindPoint(pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipeline(pipeline, settings, "VkPipeline", "pipeline", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdBindDescriptorSets(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipelineBindPoint(pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipelineLayout(layout, settings, "VkPipelineLayout", "layout", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(firstSet, settings, "uint32_t", "firstSet", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(descriptorSetCount, settings, "uint32_t", "descriptorSetCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pDescriptorSets, descriptorSetCount, settings, "const VkDescriptorSet*", "pDescriptorSets", "const VkDescriptorSet", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorSet); + dump_separate_members(settings); + dump_type(dynamicOffsetCount, settings, "uint32_t", "dynamicOffsetCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pDynamicOffsets, dynamicOffsetCount, settings, "const uint32_t*", "pDynamicOffsets", "const uint32_t", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdClearColorImage(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImage(image, settings, "VkImage", "image", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(imageLayout, settings, "VkImageLayout", "imageLayout", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pColor, settings, "const VkClearColorValue*", "pColor", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkClearColorValue); + dump_separate_members(settings); + dump_type(rangeCount, settings, "uint32_t", "rangeCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pRanges, rangeCount, settings, "const VkImageSubresourceRange*", "pRanges", "const VkImageSubresourceRange", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageSubresourceRange); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdDispatch(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(groupCountX, settings, "uint32_t", "groupCountX", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(groupCountY, settings, "uint32_t", "groupCountY", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(groupCountZ, settings, "uint32_t", "groupCountZ", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdDispatchIndirect(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(buffer, settings, "VkBuffer", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(offset, settings, "VkDeviceSize", "offset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetEvent(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkEvent(event, settings, "VkEvent", "event", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipelineStageFlags(stageMask, settings, "VkPipelineStageFlags", "stageMask", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdResetEvent(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkEvent(event, settings, "VkEvent", "event", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipelineStageFlags(stageMask, settings, "VkPipelineStageFlags", "stageMask", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdWaitEvents(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(eventCount, settings, "uint32_t", "eventCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pEvents, eventCount, settings, "const VkEvent*", "pEvents", "const VkEvent", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkEvent); + dump_separate_members(settings); + dump_VkPipelineStageFlags(srcStageMask, settings, "VkPipelineStageFlags", "srcStageMask", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipelineStageFlags(dstStageMask, settings, "VkPipelineStageFlags", "dstStageMask", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(memoryBarrierCount, settings, "uint32_t", "memoryBarrierCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pMemoryBarriers, memoryBarrierCount, settings, "const VkMemoryBarrier*", "pMemoryBarriers", "const VkMemoryBarrier", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryBarrier); + dump_separate_members(settings); + dump_type(bufferMemoryBarrierCount, settings, "uint32_t", "bufferMemoryBarrierCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pBufferMemoryBarriers, bufferMemoryBarrierCount, settings, "const VkBufferMemoryBarrier*", "pBufferMemoryBarriers", "const VkBufferMemoryBarrier", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferMemoryBarrier); + dump_separate_members(settings); + dump_type(imageMemoryBarrierCount, settings, "uint32_t", "imageMemoryBarrierCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pImageMemoryBarriers, imageMemoryBarrierCount, settings, "const VkImageMemoryBarrier*", "pImageMemoryBarriers", "const VkImageMemoryBarrier", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageMemoryBarrier); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdPushConstants(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipelineLayout(layout, settings, "VkPipelineLayout", "layout", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkShaderStageFlags(stageFlags, settings, "VkShaderStageFlags", "stageFlags", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(offset, settings, "uint32_t", "offset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(size, settings, "uint32_t", "size", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(pValues, settings, "const void*", "pValues", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateGraphicsPipelines(ApiDumpInstance& dump_inst, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipelineCache(pipelineCache, settings, "VkPipelineCache", "pipelineCache", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(createInfoCount, settings, "uint32_t", "createInfoCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pCreateInfos, createInfoCount, settings, "const VkGraphicsPipelineCreateInfo*", "pCreateInfos", "const VkGraphicsPipelineCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkGraphicsPipelineCreateInfo); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer_array(pPipelines, createInfoCount, settings, "VkPipeline*", "pPipelines", "VkPipeline", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipeline); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateFramebuffer(ApiDumpInstance& dump_inst, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkFramebufferCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkFramebufferCreateInfo); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pFramebuffer, settings, "VkFramebuffer*", "pFramebuffer", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkFramebuffer); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyFramebuffer(ApiDumpInstance& dump_inst, VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkFramebuffer(framebuffer, settings, "VkFramebuffer", "framebuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateRenderPass(ApiDumpInstance& dump_inst, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkRenderPassCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderPassCreateInfo); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pRenderPass, settings, "VkRenderPass*", "pRenderPass", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderPass); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyRenderPass(ApiDumpInstance& dump_inst, VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkRenderPass(renderPass, settings, "VkRenderPass", "renderPass", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetRenderAreaGranularity(ApiDumpInstance& dump_inst, VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkRenderPass(renderPass, settings, "VkRenderPass", "renderPass", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pGranularity, settings, "VkExtent2D*", "pGranularity", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkExtent2D); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetViewport(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(firstViewport, settings, "uint32_t", "firstViewport", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(viewportCount, settings, "uint32_t", "viewportCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pViewports, viewportCount, settings, "const VkViewport*", "pViewports", "const VkViewport", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkViewport); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetScissor(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(firstScissor, settings, "uint32_t", "firstScissor", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(scissorCount, settings, "uint32_t", "scissorCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pScissors, scissorCount, settings, "const VkRect2D*", "pScissors", "const VkRect2D", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRect2D); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetLineWidth(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, float lineWidth) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(lineWidth, settings, "float", "lineWidth", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetDepthBias(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(depthBiasConstantFactor, settings, "float", "depthBiasConstantFactor", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(depthBiasClamp, settings, "float", "depthBiasClamp", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(depthBiasSlopeFactor, settings, "float", "depthBiasSlopeFactor", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetBlendConstants(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const float blendConstants[4]) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(blendConstants, 4, settings, "const float[4]", "blendConstants", "const float", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetDepthBounds(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(minDepthBounds, settings, "float", "minDepthBounds", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(maxDepthBounds, settings, "float", "maxDepthBounds", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetStencilCompareMask(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkStencilFaceFlags(faceMask, settings, "VkStencilFaceFlags", "faceMask", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(compareMask, settings, "uint32_t", "compareMask", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetStencilWriteMask(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkStencilFaceFlags(faceMask, settings, "VkStencilFaceFlags", "faceMask", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(writeMask, settings, "uint32_t", "writeMask", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetStencilReference(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkStencilFaceFlags(faceMask, settings, "VkStencilFaceFlags", "faceMask", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(reference, settings, "uint32_t", "reference", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdBindIndexBuffer(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(buffer, settings, "VkBuffer", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(offset, settings, "VkDeviceSize", "offset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkIndexType(indexType, settings, "VkIndexType", "indexType", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdBindVertexBuffers(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(firstBinding, settings, "uint32_t", "firstBinding", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(bindingCount, settings, "uint32_t", "bindingCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pBuffers, bindingCount, settings, "const VkBuffer*", "pBuffers", "const VkBuffer", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBuffer); + dump_separate_members(settings); + dump_pointer_array(pOffsets, bindingCount, settings, "const VkDeviceSize*", "pOffsets", "const VkDeviceSize", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdDraw(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(vertexCount, settings, "uint32_t", "vertexCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(instanceCount, settings, "uint32_t", "instanceCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(firstVertex, settings, "uint32_t", "firstVertex", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(firstInstance, settings, "uint32_t", "firstInstance", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdDrawIndexed(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(indexCount, settings, "uint32_t", "indexCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(instanceCount, settings, "uint32_t", "instanceCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(firstIndex, settings, "uint32_t", "firstIndex", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(vertexOffset, settings, "int32_t", "vertexOffset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(firstInstance, settings, "uint32_t", "firstInstance", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdDrawIndirect(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(buffer, settings, "VkBuffer", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(offset, settings, "VkDeviceSize", "offset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(drawCount, settings, "uint32_t", "drawCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(stride, settings, "uint32_t", "stride", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdDrawIndexedIndirect(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(buffer, settings, "VkBuffer", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(offset, settings, "VkDeviceSize", "offset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(drawCount, settings, "uint32_t", "drawCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(stride, settings, "uint32_t", "stride", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdBlitImage(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImage(srcImage, settings, "VkImage", "srcImage", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(srcImageLayout, settings, "VkImageLayout", "srcImageLayout", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImage(dstImage, settings, "VkImage", "dstImage", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(dstImageLayout, settings, "VkImageLayout", "dstImageLayout", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(regionCount, settings, "uint32_t", "regionCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pRegions, regionCount, settings, "const VkImageBlit*", "pRegions", "const VkImageBlit", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageBlit); + dump_separate_members(settings); + dump_VkFilter(filter, settings, "VkFilter", "filter", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdClearDepthStencilImage(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImage(image, settings, "VkImage", "image", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(imageLayout, settings, "VkImageLayout", "imageLayout", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pDepthStencil, settings, "const VkClearDepthStencilValue*", "pDepthStencil", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkClearDepthStencilValue); + dump_separate_members(settings); + dump_type(rangeCount, settings, "uint32_t", "rangeCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pRanges, rangeCount, settings, "const VkImageSubresourceRange*", "pRanges", "const VkImageSubresourceRange", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageSubresourceRange); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdClearAttachments(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(attachmentCount, settings, "uint32_t", "attachmentCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pAttachments, attachmentCount, settings, "const VkClearAttachment*", "pAttachments", "const VkClearAttachment", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkClearAttachment); + dump_separate_members(settings); + dump_type(rectCount, settings, "uint32_t", "rectCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pRects, rectCount, settings, "const VkClearRect*", "pRects", "const VkClearRect", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkClearRect); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdResolveImage(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImage(srcImage, settings, "VkImage", "srcImage", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(srcImageLayout, settings, "VkImageLayout", "srcImageLayout", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImage(dstImage, settings, "VkImage", "dstImage", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(dstImageLayout, settings, "VkImageLayout", "dstImageLayout", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(regionCount, settings, "uint32_t", "regionCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pRegions, regionCount, settings, "const VkImageResolve*", "pRegions", "const VkImageResolve", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageResolve); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdBeginRenderPass(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pRenderPassBegin, settings, "const VkRenderPassBeginInfo*", "pRenderPassBegin", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderPassBeginInfo); + dump_separate_members(settings); + dump_VkSubpassContents(contents, settings, "VkSubpassContents", "contents", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdNextSubpass(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkSubpassContents contents) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkSubpassContents(contents, settings, "VkSubpassContents", "contents", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdEndRenderPass(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkBindBufferMemory2(ApiDumpInstance& dump_inst, VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(bindInfoCount, settings, "uint32_t", "bindInfoCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pBindInfos, bindInfoCount, settings, "const VkBindBufferMemoryInfo*", "pBindInfos", "const VkBindBufferMemoryInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBindBufferMemoryInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkBindImageMemory2(ApiDumpInstance& dump_inst, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(bindInfoCount, settings, "uint32_t", "bindInfoCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pBindInfos, bindInfoCount, settings, "const VkBindImageMemoryInfo*", "pBindInfos", "const VkBindImageMemoryInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBindImageMemoryInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetDeviceGroupPeerMemoryFeatures(ApiDumpInstance& dump_inst, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(heapIndex, settings, "uint32_t", "heapIndex", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(localDeviceIndex, settings, "uint32_t", "localDeviceIndex", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(remoteDeviceIndex, settings, "uint32_t", "remoteDeviceIndex", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pPeerMemoryFeatures, settings, "VkPeerMemoryFeatureFlags*", "pPeerMemoryFeatures", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPeerMemoryFeatureFlags); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetDeviceMask(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t deviceMask) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(deviceMask, settings, "uint32_t", "deviceMask", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkEnumeratePhysicalDeviceGroups(ApiDumpInstance& dump_inst, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkInstance(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pPhysicalDeviceGroupCount, settings, "uint32_t*", "pPhysicalDeviceGroupCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pPhysicalDeviceGroupProperties, *pPhysicalDeviceGroupCount, settings, "VkPhysicalDeviceGroupProperties*", "pPhysicalDeviceGroupProperties", "VkPhysicalDeviceGroupProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceGroupProperties); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetImageMemoryRequirements2(ApiDumpInstance& dump_inst, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkImageMemoryRequirementsInfo2*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageMemoryRequirementsInfo2); + dump_separate_members(settings); + dump_pointer(pMemoryRequirements, settings, "VkMemoryRequirements2*", "pMemoryRequirements", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetBufferMemoryRequirements2(ApiDumpInstance& dump_inst, VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkBufferMemoryRequirementsInfo2*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferMemoryRequirementsInfo2); + dump_separate_members(settings); + dump_pointer(pMemoryRequirements, settings, "VkMemoryRequirements2*", "pMemoryRequirements", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetImageSparseMemoryRequirements2(ApiDumpInstance& dump_inst, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkImageSparseMemoryRequirementsInfo2*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageSparseMemoryRequirementsInfo2); + dump_separate_members(settings); + dump_pointer(pSparseMemoryRequirementCount, settings, "uint32_t*", "pSparseMemoryRequirementCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pSparseMemoryRequirements, *pSparseMemoryRequirementCount, settings, "VkSparseImageMemoryRequirements2*", "pSparseMemoryRequirements", "VkSparseImageMemoryRequirements2", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSparseImageMemoryRequirements2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceFeatures2(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pFeatures, settings, "VkPhysicalDeviceFeatures2*", "pFeatures", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceFeatures2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceProperties2(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pProperties, settings, "VkPhysicalDeviceProperties2*", "pProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceProperties2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceFormatProperties2(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkFormat(format, settings, "VkFormat", "format", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pFormatProperties, settings, "VkFormatProperties2*", "pFormatProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkFormatProperties2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceImageFormatProperties2(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pImageFormatInfo, settings, "const VkPhysicalDeviceImageFormatInfo2*", "pImageFormatInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceImageFormatInfo2); + dump_separate_members(settings); + dump_pointer(pImageFormatProperties, settings, "VkImageFormatProperties2*", "pImageFormatProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageFormatProperties2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceQueueFamilyProperties2(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pQueueFamilyPropertyCount, settings, "uint32_t*", "pQueueFamilyPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pQueueFamilyProperties, *pQueueFamilyPropertyCount, settings, "VkQueueFamilyProperties2*", "pQueueFamilyProperties", "VkQueueFamilyProperties2", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkQueueFamilyProperties2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceMemoryProperties2(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pMemoryProperties, settings, "VkPhysicalDeviceMemoryProperties2*", "pMemoryProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceMemoryProperties2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceSparseImageFormatProperties2(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pFormatInfo, settings, "const VkPhysicalDeviceSparseImageFormatInfo2*", "pFormatInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceSparseImageFormatInfo2); + dump_separate_members(settings); + dump_pointer(pPropertyCount, settings, "uint32_t*", "pPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pProperties, *pPropertyCount, settings, "VkSparseImageFormatProperties2*", "pProperties", "VkSparseImageFormatProperties2", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSparseImageFormatProperties2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkTrimCommandPool(ApiDumpInstance& dump_inst, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkCommandPool(commandPool, settings, "VkCommandPool", "commandPool", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkCommandPoolTrimFlags(flags, settings, "VkCommandPoolTrimFlags", "flags", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetDeviceQueue2(ApiDumpInstance& dump_inst, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pQueueInfo, settings, "const VkDeviceQueueInfo2*", "pQueueInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceQueueInfo2); + dump_separate_members(settings); + dump_pointer(pQueue, settings, "VkQueue*", "pQueue", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkQueue); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceExternalBufferProperties(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pExternalBufferInfo, settings, "const VkPhysicalDeviceExternalBufferInfo*", "pExternalBufferInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceExternalBufferInfo); + dump_separate_members(settings); + dump_pointer(pExternalBufferProperties, settings, "VkExternalBufferProperties*", "pExternalBufferProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkExternalBufferProperties); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceExternalFenceProperties(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pExternalFenceInfo, settings, "const VkPhysicalDeviceExternalFenceInfo*", "pExternalFenceInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceExternalFenceInfo); + dump_separate_members(settings); + dump_pointer(pExternalFenceProperties, settings, "VkExternalFenceProperties*", "pExternalFenceProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkExternalFenceProperties); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceExternalSemaphoreProperties(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pExternalSemaphoreInfo, settings, "const VkPhysicalDeviceExternalSemaphoreInfo*", "pExternalSemaphoreInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceExternalSemaphoreInfo); + dump_separate_members(settings); + dump_pointer(pExternalSemaphoreProperties, settings, "VkExternalSemaphoreProperties*", "pExternalSemaphoreProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkExternalSemaphoreProperties); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdDispatchBase(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(baseGroupX, settings, "uint32_t", "baseGroupX", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(baseGroupY, settings, "uint32_t", "baseGroupY", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(baseGroupZ, settings, "uint32_t", "baseGroupZ", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(groupCountX, settings, "uint32_t", "groupCountX", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(groupCountY, settings, "uint32_t", "groupCountY", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(groupCountZ, settings, "uint32_t", "groupCountZ", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateDescriptorUpdateTemplate(ApiDumpInstance& dump_inst, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkDescriptorUpdateTemplateCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorUpdateTemplateCreateInfo); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pDescriptorUpdateTemplate, settings, "VkDescriptorUpdateTemplate*", "pDescriptorUpdateTemplate", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorUpdateTemplate); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyDescriptorUpdateTemplate(ApiDumpInstance& dump_inst, VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDescriptorUpdateTemplate(descriptorUpdateTemplate, settings, "VkDescriptorUpdateTemplate", "descriptorUpdateTemplate", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkUpdateDescriptorSetWithTemplate(ApiDumpInstance& dump_inst, VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDescriptorSet(descriptorSet, settings, "VkDescriptorSet", "descriptorSet", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDescriptorUpdateTemplate(descriptorUpdateTemplate, settings, "VkDescriptorUpdateTemplate", "descriptorUpdateTemplate", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(pData, settings, "const void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetDescriptorSetLayoutSupport(ApiDumpInstance& dump_inst, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkDescriptorSetLayoutCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorSetLayoutCreateInfo); + dump_separate_members(settings); + dump_pointer(pSupport, settings, "VkDescriptorSetLayoutSupport*", "pSupport", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorSetLayoutSupport); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateSamplerYcbcrConversion(ApiDumpInstance& dump_inst, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkSamplerYcbcrConversionCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSamplerYcbcrConversionCreateInfo); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pYcbcrConversion, settings, "VkSamplerYcbcrConversion*", "pYcbcrConversion", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSamplerYcbcrConversion); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroySamplerYcbcrConversion(ApiDumpInstance& dump_inst, VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkSamplerYcbcrConversion(ycbcrConversion, settings, "VkSamplerYcbcrConversion", "ycbcrConversion", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkResetQueryPool(ApiDumpInstance& dump_inst, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkQueryPool(queryPool, settings, "VkQueryPool", "queryPool", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(firstQuery, settings, "uint32_t", "firstQuery", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(queryCount, settings, "uint32_t", "queryCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetSemaphoreCounterValue(ApiDumpInstance& dump_inst, VkDevice device, VkSemaphore semaphore, uint64_t* pValue) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkSemaphore(semaphore, settings, "VkSemaphore", "semaphore", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pValue, settings, "uint64_t*", "pValue", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkWaitSemaphores(ApiDumpInstance& dump_inst, VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pWaitInfo, settings, "const VkSemaphoreWaitInfo*", "pWaitInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSemaphoreWaitInfo); + dump_separate_members(settings); + dump_type(timeout, settings, "uint64_t", "timeout", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkSignalSemaphore(ApiDumpInstance& dump_inst, VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pSignalInfo, settings, "const VkSemaphoreSignalInfo*", "pSignalInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSemaphoreSignalInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetBufferDeviceAddress(ApiDumpInstance& dump_inst, VkDevice device, const VkBufferDeviceAddressInfo* pInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkBufferDeviceAddressInfo*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferDeviceAddressInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetBufferOpaqueCaptureAddress(ApiDumpInstance& dump_inst, VkDevice device, const VkBufferDeviceAddressInfo* pInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkBufferDeviceAddressInfo*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferDeviceAddressInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetDeviceMemoryOpaqueCaptureAddress(ApiDumpInstance& dump_inst, VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkDeviceMemoryOpaqueCaptureAddressInfo*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceMemoryOpaqueCaptureAddressInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdDrawIndirectCount(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(buffer, settings, "VkBuffer", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(offset, settings, "VkDeviceSize", "offset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(countBuffer, settings, "VkBuffer", "countBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(countBufferOffset, settings, "VkDeviceSize", "countBufferOffset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(maxDrawCount, settings, "uint32_t", "maxDrawCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(stride, settings, "uint32_t", "stride", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdDrawIndexedIndirectCount(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(buffer, settings, "VkBuffer", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(offset, settings, "VkDeviceSize", "offset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(countBuffer, settings, "VkBuffer", "countBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(countBufferOffset, settings, "VkDeviceSize", "countBufferOffset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(maxDrawCount, settings, "uint32_t", "maxDrawCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(stride, settings, "uint32_t", "stride", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateRenderPass2(ApiDumpInstance& dump_inst, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkRenderPassCreateInfo2*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderPassCreateInfo2); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pRenderPass, settings, "VkRenderPass*", "pRenderPass", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderPass); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdBeginRenderPass2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pRenderPassBegin, settings, "const VkRenderPassBeginInfo*", "pRenderPassBegin", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderPassBeginInfo); + dump_separate_members(settings); + dump_pointer(pSubpassBeginInfo, settings, "const VkSubpassBeginInfo*", "pSubpassBeginInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSubpassBeginInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdNextSubpass2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pSubpassBeginInfo, settings, "const VkSubpassBeginInfo*", "pSubpassBeginInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSubpassBeginInfo); + dump_separate_members(settings); + dump_pointer(pSubpassEndInfo, settings, "const VkSubpassEndInfo*", "pSubpassEndInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSubpassEndInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdEndRenderPass2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pSubpassEndInfo, settings, "const VkSubpassEndInfo*", "pSubpassEndInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSubpassEndInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceToolProperties(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pToolCount, settings, "uint32_t*", "pToolCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pToolProperties, *pToolCount, settings, "VkPhysicalDeviceToolProperties*", "pToolProperties", "VkPhysicalDeviceToolProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceToolProperties); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreatePrivateDataSlot(ApiDumpInstance& dump_inst, VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkPrivateDataSlotCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPrivateDataSlotCreateInfo); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pPrivateDataSlot, settings, "VkPrivateDataSlot*", "pPrivateDataSlot", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPrivateDataSlot); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyPrivateDataSlot(ApiDumpInstance& dump_inst, VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPrivateDataSlot(privateDataSlot, settings, "VkPrivateDataSlot", "privateDataSlot", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkSetPrivateData(ApiDumpInstance& dump_inst, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkObjectType(objectType, settings, "VkObjectType", "objectType", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_uint64_t_as_pointer(objectHandle, settings, "uint64_t", "objectHandle", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPrivateDataSlot(privateDataSlot, settings, "VkPrivateDataSlot", "privateDataSlot", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(data, settings, "uint64_t", "data", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPrivateData(ApiDumpInstance& dump_inst, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkObjectType(objectType, settings, "VkObjectType", "objectType", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_uint64_t_as_pointer(objectHandle, settings, "uint64_t", "objectHandle", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPrivateDataSlot(privateDataSlot, settings, "VkPrivateDataSlot", "privateDataSlot", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pData, settings, "uint64_t*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdPipelineBarrier2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pDependencyInfo, settings, "const VkDependencyInfo*", "pDependencyInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDependencyInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdWriteTimestamp2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipelineStageFlags2(stage, settings, "VkPipelineStageFlags2", "stage", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkQueryPool(queryPool, settings, "VkQueryPool", "queryPool", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(query, settings, "uint32_t", "query", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkQueueSubmit2(ApiDumpInstance& dump_inst, VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkQueue(queue, settings, "VkQueue", "queue", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(submitCount, settings, "uint32_t", "submitCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pSubmits, submitCount, settings, "const VkSubmitInfo2*", "pSubmits", "const VkSubmitInfo2", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSubmitInfo2); + dump_separate_members(settings); + dump_VkFence(fence, settings, "VkFence", "fence", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdCopyBuffer2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCopyBufferInfo, settings, "const VkCopyBufferInfo2*", "pCopyBufferInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyBufferInfo2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdCopyImage2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCopyImageInfo, settings, "const VkCopyImageInfo2*", "pCopyImageInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyImageInfo2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdCopyBufferToImage2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCopyBufferToImageInfo, settings, "const VkCopyBufferToImageInfo2*", "pCopyBufferToImageInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyBufferToImageInfo2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdCopyImageToBuffer2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCopyImageToBufferInfo, settings, "const VkCopyImageToBufferInfo2*", "pCopyImageToBufferInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyImageToBufferInfo2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetDeviceBufferMemoryRequirements(ApiDumpInstance& dump_inst, VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkDeviceBufferMemoryRequirements*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceBufferMemoryRequirements); + dump_separate_members(settings); + dump_pointer(pMemoryRequirements, settings, "VkMemoryRequirements2*", "pMemoryRequirements", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetDeviceImageMemoryRequirements(ApiDumpInstance& dump_inst, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkDeviceImageMemoryRequirements*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceImageMemoryRequirements); + dump_separate_members(settings); + dump_pointer(pMemoryRequirements, settings, "VkMemoryRequirements2*", "pMemoryRequirements", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetDeviceImageSparseMemoryRequirements(ApiDumpInstance& dump_inst, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkDeviceImageMemoryRequirements*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceImageMemoryRequirements); + dump_separate_members(settings); + dump_pointer(pSparseMemoryRequirementCount, settings, "uint32_t*", "pSparseMemoryRequirementCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pSparseMemoryRequirements, *pSparseMemoryRequirementCount, settings, "VkSparseImageMemoryRequirements2*", "pSparseMemoryRequirements", "VkSparseImageMemoryRequirements2", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSparseImageMemoryRequirements2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetEvent2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkEvent(event, settings, "VkEvent", "event", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pDependencyInfo, settings, "const VkDependencyInfo*", "pDependencyInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDependencyInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdResetEvent2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkEvent(event, settings, "VkEvent", "event", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipelineStageFlags2(stageMask, settings, "VkPipelineStageFlags2", "stageMask", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdWaitEvents2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(eventCount, settings, "uint32_t", "eventCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pEvents, eventCount, settings, "const VkEvent*", "pEvents", "const VkEvent", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkEvent); + dump_separate_members(settings); + dump_pointer_array(pDependencyInfos, eventCount, settings, "const VkDependencyInfo*", "pDependencyInfos", "const VkDependencyInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDependencyInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdBlitImage2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pBlitImageInfo, settings, "const VkBlitImageInfo2*", "pBlitImageInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBlitImageInfo2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdResolveImage2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pResolveImageInfo, settings, "const VkResolveImageInfo2*", "pResolveImageInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkResolveImageInfo2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdBeginRendering(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pRenderingInfo, settings, "const VkRenderingInfo*", "pRenderingInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderingInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdEndRendering(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetCullMode(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkCullModeFlags(cullMode, settings, "VkCullModeFlags", "cullMode", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetFrontFace(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkFrontFace frontFace) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkFrontFace(frontFace, settings, "VkFrontFace", "frontFace", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetPrimitiveTopology(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPrimitiveTopology(primitiveTopology, settings, "VkPrimitiveTopology", "primitiveTopology", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetViewportWithCount(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(viewportCount, settings, "uint32_t", "viewportCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pViewports, viewportCount, settings, "const VkViewport*", "pViewports", "const VkViewport", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkViewport); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetScissorWithCount(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(scissorCount, settings, "uint32_t", "scissorCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pScissors, scissorCount, settings, "const VkRect2D*", "pScissors", "const VkRect2D", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRect2D); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdBindVertexBuffers2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(firstBinding, settings, "uint32_t", "firstBinding", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(bindingCount, settings, "uint32_t", "bindingCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pBuffers, bindingCount, settings, "const VkBuffer*", "pBuffers", "const VkBuffer", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBuffer); + dump_separate_members(settings); + dump_pointer_array(pOffsets, bindingCount, settings, "const VkDeviceSize*", "pOffsets", "const VkDeviceSize", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pSizes, bindingCount, settings, "const VkDeviceSize*", "pSizes", "const VkDeviceSize", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pStrides, bindingCount, settings, "const VkDeviceSize*", "pStrides", "const VkDeviceSize", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetDepthTestEnable(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(depthTestEnable, settings, "VkBool32", "depthTestEnable", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetDepthWriteEnable(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(depthWriteEnable, settings, "VkBool32", "depthWriteEnable", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetDepthCompareOp(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkCompareOp(depthCompareOp, settings, "VkCompareOp", "depthCompareOp", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetDepthBoundsTestEnable(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(depthBoundsTestEnable, settings, "VkBool32", "depthBoundsTestEnable", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetStencilTestEnable(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(stencilTestEnable, settings, "VkBool32", "stencilTestEnable", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetStencilOp(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkStencilFaceFlags(faceMask, settings, "VkStencilFaceFlags", "faceMask", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkStencilOp(failOp, settings, "VkStencilOp", "failOp", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkStencilOp(passOp, settings, "VkStencilOp", "passOp", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkStencilOp(depthFailOp, settings, "VkStencilOp", "depthFailOp", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkCompareOp(compareOp, settings, "VkCompareOp", "compareOp", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetRasterizerDiscardEnable(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(rasterizerDiscardEnable, settings, "VkBool32", "rasterizerDiscardEnable", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetDepthBiasEnable(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(depthBiasEnable, settings, "VkBool32", "depthBiasEnable", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetPrimitiveRestartEnable(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(primitiveRestartEnable, settings, "VkBool32", "primitiveRestartEnable", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkMapMemory2(ApiDumpInstance& dump_inst, VkDevice device, const VkMemoryMapInfo* pMemoryMapInfo, void** ppData) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pMemoryMapInfo, settings, "const VkMemoryMapInfo*", "pMemoryMapInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryMapInfo); + dump_separate_members(settings); + dump_type(ppData, settings, "void**", "ppData", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkUnmapMemory2(ApiDumpInstance& dump_inst, VkDevice device, const VkMemoryUnmapInfo* pMemoryUnmapInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pMemoryUnmapInfo, settings, "const VkMemoryUnmapInfo*", "pMemoryUnmapInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryUnmapInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetDeviceImageSubresourceLayout(ApiDumpInstance& dump_inst, VkDevice device, const VkDeviceImageSubresourceInfo* pInfo, VkSubresourceLayout2* pLayout) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkDeviceImageSubresourceInfo*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceImageSubresourceInfo); + dump_separate_members(settings); + dump_pointer(pLayout, settings, "VkSubresourceLayout2*", "pLayout", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSubresourceLayout2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetImageSubresourceLayout2(ApiDumpInstance& dump_inst, VkDevice device, VkImage image, const VkImageSubresource2* pSubresource, VkSubresourceLayout2* pLayout) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImage(image, settings, "VkImage", "image", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pSubresource, settings, "const VkImageSubresource2*", "pSubresource", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageSubresource2); + dump_separate_members(settings); + dump_pointer(pLayout, settings, "VkSubresourceLayout2*", "pLayout", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSubresourceLayout2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCopyMemoryToImage(ApiDumpInstance& dump_inst, VkDevice device, const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCopyMemoryToImageInfo, settings, "const VkCopyMemoryToImageInfo*", "pCopyMemoryToImageInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyMemoryToImageInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCopyImageToMemory(ApiDumpInstance& dump_inst, VkDevice device, const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCopyImageToMemoryInfo, settings, "const VkCopyImageToMemoryInfo*", "pCopyImageToMemoryInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyImageToMemoryInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCopyImageToImage(ApiDumpInstance& dump_inst, VkDevice device, const VkCopyImageToImageInfo* pCopyImageToImageInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCopyImageToImageInfo, settings, "const VkCopyImageToImageInfo*", "pCopyImageToImageInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyImageToImageInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkTransitionImageLayout(ApiDumpInstance& dump_inst, VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfo* pTransitions) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(transitionCount, settings, "uint32_t", "transitionCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pTransitions, transitionCount, settings, "const VkHostImageLayoutTransitionInfo*", "pTransitions", "const VkHostImageLayoutTransitionInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkHostImageLayoutTransitionInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdPushDescriptorSet(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipelineBindPoint(pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipelineLayout(layout, settings, "VkPipelineLayout", "layout", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(set, settings, "uint32_t", "set", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(descriptorWriteCount, settings, "uint32_t", "descriptorWriteCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pDescriptorWrites, descriptorWriteCount, settings, "const VkWriteDescriptorSet*", "pDescriptorWrites", "const VkWriteDescriptorSet", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkWriteDescriptorSet); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdPushDescriptorSetWithTemplate(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDescriptorUpdateTemplate(descriptorUpdateTemplate, settings, "VkDescriptorUpdateTemplate", "descriptorUpdateTemplate", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipelineLayout(layout, settings, "VkPipelineLayout", "layout", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(set, settings, "uint32_t", "set", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(pData, settings, "const void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdBindDescriptorSets2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pBindDescriptorSetsInfo, settings, "const VkBindDescriptorSetsInfo*", "pBindDescriptorSetsInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBindDescriptorSetsInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdPushConstants2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkPushConstantsInfo* pPushConstantsInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pPushConstantsInfo, settings, "const VkPushConstantsInfo*", "pPushConstantsInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPushConstantsInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdPushDescriptorSet2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfo* pPushDescriptorSetInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pPushDescriptorSetInfo, settings, "const VkPushDescriptorSetInfo*", "pPushDescriptorSetInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPushDescriptorSetInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdPushDescriptorSetWithTemplate2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pPushDescriptorSetWithTemplateInfo, settings, "const VkPushDescriptorSetWithTemplateInfo*", "pPushDescriptorSetWithTemplateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPushDescriptorSetWithTemplateInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetLineStipple(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(lineStippleFactor, settings, "uint32_t", "lineStippleFactor", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(lineStipplePattern, settings, "uint16_t", "lineStipplePattern", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdBindIndexBuffer2(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(buffer, settings, "VkBuffer", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(offset, settings, "VkDeviceSize", "offset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(size, settings, "VkDeviceSize", "size", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkIndexType(indexType, settings, "VkIndexType", "indexType", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetRenderingAreaGranularity(ApiDumpInstance& dump_inst, VkDevice device, const VkRenderingAreaInfo* pRenderingAreaInfo, VkExtent2D* pGranularity) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pRenderingAreaInfo, settings, "const VkRenderingAreaInfo*", "pRenderingAreaInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderingAreaInfo); + dump_separate_members(settings); + dump_pointer(pGranularity, settings, "VkExtent2D*", "pGranularity", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkExtent2D); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetRenderingAttachmentLocations(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkRenderingAttachmentLocationInfo* pLocationInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pLocationInfo, settings, "const VkRenderingAttachmentLocationInfo*", "pLocationInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderingAttachmentLocationInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetRenderingInputAttachmentIndices(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInputAttachmentIndexInfo, settings, "const VkRenderingInputAttachmentIndexInfo*", "pInputAttachmentIndexInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderingInputAttachmentIndexInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroySurfaceKHR(ApiDumpInstance& dump_inst, VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkInstance(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkSurfaceKHR(surface, settings, "VkSurfaceKHR", "surface", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceSurfaceSupportKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkSurfaceKHR(surface, settings, "VkSurfaceKHR", "surface", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pSupported, settings, "VkBool32*", "pSupported", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkSurfaceKHR(surface, settings, "VkSurfaceKHR", "surface", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pSurfaceCapabilities, settings, "VkSurfaceCapabilitiesKHR*", "pSurfaceCapabilities", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceCapabilitiesKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceSurfaceFormatsKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkSurfaceKHR(surface, settings, "VkSurfaceKHR", "surface", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pSurfaceFormatCount, settings, "uint32_t*", "pSurfaceFormatCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pSurfaceFormats, *pSurfaceFormatCount, settings, "VkSurfaceFormatKHR*", "pSurfaceFormats", "VkSurfaceFormatKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceFormatKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceSurfacePresentModesKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkSurfaceKHR(surface, settings, "VkSurfaceKHR", "surface", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pPresentModeCount, settings, "uint32_t*", "pPresentModeCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pPresentModes, *pPresentModeCount, settings, "VkPresentModeKHR*", "pPresentModes", "VkPresentModeKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPresentModeKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateSwapchainKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkSwapchainCreateInfoKHR*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSwapchainCreateInfoKHR); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pSwapchain, settings, "VkSwapchainKHR*", "pSwapchain", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSwapchainKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroySwapchainKHR(ApiDumpInstance& dump_inst, VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkSwapchainKHR(swapchain, settings, "VkSwapchainKHR", "swapchain", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetSwapchainImagesKHR(ApiDumpInstance& dump_inst, VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkSwapchainKHR(swapchain, settings, "VkSwapchainKHR", "swapchain", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pSwapchainImageCount, settings, "uint32_t*", "pSwapchainImageCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pSwapchainImages, *pSwapchainImageCount, settings, "VkImage*", "pSwapchainImages", "VkImage", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImage); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkAcquireNextImageKHR(ApiDumpInstance& dump_inst, VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkSwapchainKHR(swapchain, settings, "VkSwapchainKHR", "swapchain", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(timeout, settings, "uint64_t", "timeout", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkSemaphore(semaphore, settings, "VkSemaphore", "semaphore", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkFence(fence, settings, "VkFence", "fence", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pImageIndex, settings, "uint32_t*", "pImageIndex", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkQueuePresentKHR(ApiDumpInstance& dump_inst, VkQueue queue, const VkPresentInfoKHR* pPresentInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkQueue(queue, settings, "VkQueue", "queue", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pPresentInfo, settings, "const VkPresentInfoKHR*", "pPresentInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPresentInfoKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetDeviceGroupPresentCapabilitiesKHR(ApiDumpInstance& dump_inst, VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pDeviceGroupPresentCapabilities, settings, "VkDeviceGroupPresentCapabilitiesKHR*", "pDeviceGroupPresentCapabilities", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceGroupPresentCapabilitiesKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetDeviceGroupSurfacePresentModesKHR(ApiDumpInstance& dump_inst, VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkSurfaceKHR(surface, settings, "VkSurfaceKHR", "surface", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pModes, settings, "VkDeviceGroupPresentModeFlagsKHR*", "pModes", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceGroupPresentModeFlagsKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDevicePresentRectanglesKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkSurfaceKHR(surface, settings, "VkSurfaceKHR", "surface", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pRectCount, settings, "uint32_t*", "pRectCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pRects, *pRectCount, settings, "VkRect2D*", "pRects", "VkRect2D", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRect2D); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkAcquireNextImage2KHR(ApiDumpInstance& dump_inst, VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAcquireInfo, settings, "const VkAcquireNextImageInfoKHR*", "pAcquireInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAcquireNextImageInfoKHR); + dump_separate_members(settings); + dump_pointer(pImageIndex, settings, "uint32_t*", "pImageIndex", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceDisplayPropertiesKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pPropertyCount, settings, "uint32_t*", "pPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pProperties, *pPropertyCount, settings, "VkDisplayPropertiesKHR*", "pProperties", "VkDisplayPropertiesKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayPropertiesKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pPropertyCount, settings, "uint32_t*", "pPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pProperties, *pPropertyCount, settings, "VkDisplayPlanePropertiesKHR*", "pProperties", "VkDisplayPlanePropertiesKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayPlanePropertiesKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetDisplayPlaneSupportedDisplaysKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(planeIndex, settings, "uint32_t", "planeIndex", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pDisplayCount, settings, "uint32_t*", "pDisplayCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pDisplays, *pDisplayCount, settings, "VkDisplayKHR*", "pDisplays", "VkDisplayKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetDisplayModePropertiesKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDisplayKHR(display, settings, "VkDisplayKHR", "display", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pPropertyCount, settings, "uint32_t*", "pPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pProperties, *pPropertyCount, settings, "VkDisplayModePropertiesKHR*", "pProperties", "VkDisplayModePropertiesKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayModePropertiesKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateDisplayModeKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDisplayKHR(display, settings, "VkDisplayKHR", "display", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkDisplayModeCreateInfoKHR*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayModeCreateInfoKHR); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pMode, settings, "VkDisplayModeKHR*", "pMode", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayModeKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetDisplayPlaneCapabilitiesKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDisplayModeKHR(mode, settings, "VkDisplayModeKHR", "mode", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(planeIndex, settings, "uint32_t", "planeIndex", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCapabilities, settings, "VkDisplayPlaneCapabilitiesKHR*", "pCapabilities", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayPlaneCapabilitiesKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateDisplayPlaneSurfaceKHR(ApiDumpInstance& dump_inst, VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkInstance(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkDisplaySurfaceCreateInfoKHR*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplaySurfaceCreateInfoKHR); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pSurface, settings, "VkSurfaceKHR*", "pSurface", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateSharedSwapchainsKHR(ApiDumpInstance& dump_inst, VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(swapchainCount, settings, "uint32_t", "swapchainCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pCreateInfos, swapchainCount, settings, "const VkSwapchainCreateInfoKHR*", "pCreateInfos", "const VkSwapchainCreateInfoKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSwapchainCreateInfoKHR); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer_array(pSwapchains, swapchainCount, settings, "VkSwapchainKHR*", "pSwapchains", "VkSwapchainKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSwapchainKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} +#if defined(VK_USE_PLATFORM_XLIB_KHR) + +template +void dump_params_vkCreateXlibSurfaceKHR(ApiDumpInstance& dump_inst, VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkInstance(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkXlibSurfaceCreateInfoKHR*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkXlibSurfaceCreateInfoKHR); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pSurface, settings, "VkSurfaceKHR*", "pSurface", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceXlibPresentationSupportKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(dpy, settings, "Display*", "dpy", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(visualID, settings, "VisualID", "visualID", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} +#endif // VK_USE_PLATFORM_XLIB_KHR +#if defined(VK_USE_PLATFORM_XCB_KHR) + +template +void dump_params_vkCreateXcbSurfaceKHR(ApiDumpInstance& dump_inst, VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkInstance(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkXcbSurfaceCreateInfoKHR*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkXcbSurfaceCreateInfoKHR); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pSurface, settings, "VkSurfaceKHR*", "pSurface", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceXcbPresentationSupportKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(connection, settings, "xcb_connection_t*", "connection", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(visual_id, settings, "xcb_visualid_t", "visual_id", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} +#endif // VK_USE_PLATFORM_XCB_KHR +#if defined(VK_USE_PLATFORM_WAYLAND_KHR) + +template +void dump_params_vkCreateWaylandSurfaceKHR(ApiDumpInstance& dump_inst, VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkInstance(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkWaylandSurfaceCreateInfoKHR*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkWaylandSurfaceCreateInfoKHR); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pSurface, settings, "VkSurfaceKHR*", "pSurface", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceWaylandPresentationSupportKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(display, settings, "struct wl_display*", "display", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} +#endif // VK_USE_PLATFORM_WAYLAND_KHR +#if defined(VK_USE_PLATFORM_ANDROID_KHR) + +template +void dump_params_vkCreateAndroidSurfaceKHR(ApiDumpInstance& dump_inst, VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkInstance(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkAndroidSurfaceCreateInfoKHR*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAndroidSurfaceCreateInfoKHR); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pSurface, settings, "VkSurfaceKHR*", "pSurface", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} +#endif // VK_USE_PLATFORM_ANDROID_KHR +#if defined(VK_USE_PLATFORM_WIN32_KHR) + +template +void dump_params_vkCreateWin32SurfaceKHR(ApiDumpInstance& dump_inst, VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkInstance(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkWin32SurfaceCreateInfoKHR*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkWin32SurfaceCreateInfoKHR); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pSurface, settings, "VkSurfaceKHR*", "pSurface", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceWin32PresentationSupportKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} +#endif // VK_USE_PLATFORM_WIN32_KHR + +template +void dump_params_vkGetPhysicalDeviceVideoCapabilitiesKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkVideoProfileInfoKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pVideoProfile, settings, "const VkVideoProfileInfoKHR*", "pVideoProfile", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoProfileInfoKHR); + dump_separate_members(settings); + dump_pointer(pCapabilities, settings, "VkVideoCapabilitiesKHR*", "pCapabilities", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoCapabilitiesKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceVideoFormatPropertiesKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pVideoFormatInfo, settings, "const VkPhysicalDeviceVideoFormatInfoKHR*", "pVideoFormatInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceVideoFormatInfoKHR); + dump_separate_members(settings); + dump_pointer(pVideoFormatPropertyCount, settings, "uint32_t*", "pVideoFormatPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pVideoFormatProperties, *pVideoFormatPropertyCount, settings, "VkVideoFormatPropertiesKHR*", "pVideoFormatProperties", "VkVideoFormatPropertiesKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoFormatPropertiesKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateVideoSessionKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkVideoSessionCreateInfoKHR*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoSessionCreateInfoKHR); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pVideoSession, settings, "VkVideoSessionKHR*", "pVideoSession", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoSessionKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyVideoSessionKHR(ApiDumpInstance& dump_inst, VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkVideoSessionKHR(videoSession, settings, "VkVideoSessionKHR", "videoSession", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetVideoSessionMemoryRequirementsKHR(ApiDumpInstance& dump_inst, VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkVideoSessionKHR(videoSession, settings, "VkVideoSessionKHR", "videoSession", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pMemoryRequirementsCount, settings, "uint32_t*", "pMemoryRequirementsCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pMemoryRequirements, *pMemoryRequirementsCount, settings, "VkVideoSessionMemoryRequirementsKHR*", "pMemoryRequirements", "VkVideoSessionMemoryRequirementsKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoSessionMemoryRequirementsKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkBindVideoSessionMemoryKHR(ApiDumpInstance& dump_inst, VkDevice device, VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkVideoSessionKHR(videoSession, settings, "VkVideoSessionKHR", "videoSession", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(bindSessionMemoryInfoCount, settings, "uint32_t", "bindSessionMemoryInfoCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pBindSessionMemoryInfos, bindSessionMemoryInfoCount, settings, "const VkBindVideoSessionMemoryInfoKHR*", "pBindSessionMemoryInfos", "const VkBindVideoSessionMemoryInfoKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBindVideoSessionMemoryInfoKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateVideoSessionParametersKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkVideoSessionParametersCreateInfoKHR*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoSessionParametersCreateInfoKHR); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pVideoSessionParameters, settings, "VkVideoSessionParametersKHR*", "pVideoSessionParameters", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoSessionParametersKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkUpdateVideoSessionParametersKHR(ApiDumpInstance& dump_inst, VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkVideoSessionParametersKHR(videoSessionParameters, settings, "VkVideoSessionParametersKHR", "videoSessionParameters", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pUpdateInfo, settings, "const VkVideoSessionParametersUpdateInfoKHR*", "pUpdateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoSessionParametersUpdateInfoKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyVideoSessionParametersKHR(ApiDumpInstance& dump_inst, VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkVideoSessionParametersKHR(videoSessionParameters, settings, "VkVideoSessionParametersKHR", "videoSessionParameters", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdBeginVideoCodingKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR* pBeginInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pBeginInfo, settings, "const VkVideoBeginCodingInfoKHR*", "pBeginInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoBeginCodingInfoKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdEndVideoCodingKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR* pEndCodingInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pEndCodingInfo, settings, "const VkVideoEndCodingInfoKHR*", "pEndCodingInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoEndCodingInfoKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdControlVideoCodingKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCodingControlInfo, settings, "const VkVideoCodingControlInfoKHR*", "pCodingControlInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoCodingControlInfoKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdDecodeVideoKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pDecodeInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pDecodeInfo, settings, "const VkVideoDecodeInfoKHR*", "pDecodeInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoDecodeInfoKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdBeginRenderingKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pRenderingInfo, settings, "const VkRenderingInfo*", "pRenderingInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderingInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdEndRenderingKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceFeatures2KHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pFeatures, settings, "VkPhysicalDeviceFeatures2*", "pFeatures", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceFeatures2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceProperties2KHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pProperties, settings, "VkPhysicalDeviceProperties2*", "pProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceProperties2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceFormatProperties2KHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkFormat(format, settings, "VkFormat", "format", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pFormatProperties, settings, "VkFormatProperties2*", "pFormatProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkFormatProperties2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceImageFormatProperties2KHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pImageFormatInfo, settings, "const VkPhysicalDeviceImageFormatInfo2*", "pImageFormatInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceImageFormatInfo2); + dump_separate_members(settings); + dump_pointer(pImageFormatProperties, settings, "VkImageFormatProperties2*", "pImageFormatProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageFormatProperties2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceQueueFamilyProperties2KHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pQueueFamilyPropertyCount, settings, "uint32_t*", "pQueueFamilyPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pQueueFamilyProperties, *pQueueFamilyPropertyCount, settings, "VkQueueFamilyProperties2*", "pQueueFamilyProperties", "VkQueueFamilyProperties2", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkQueueFamilyProperties2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceMemoryProperties2KHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pMemoryProperties, settings, "VkPhysicalDeviceMemoryProperties2*", "pMemoryProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceMemoryProperties2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pFormatInfo, settings, "const VkPhysicalDeviceSparseImageFormatInfo2*", "pFormatInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceSparseImageFormatInfo2); + dump_separate_members(settings); + dump_pointer(pPropertyCount, settings, "uint32_t*", "pPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pProperties, *pPropertyCount, settings, "VkSparseImageFormatProperties2*", "pProperties", "VkSparseImageFormatProperties2", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSparseImageFormatProperties2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetDeviceGroupPeerMemoryFeaturesKHR(ApiDumpInstance& dump_inst, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(heapIndex, settings, "uint32_t", "heapIndex", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(localDeviceIndex, settings, "uint32_t", "localDeviceIndex", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(remoteDeviceIndex, settings, "uint32_t", "remoteDeviceIndex", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pPeerMemoryFeatures, settings, "VkPeerMemoryFeatureFlags*", "pPeerMemoryFeatures", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPeerMemoryFeatureFlags); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetDeviceMaskKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t deviceMask) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(deviceMask, settings, "uint32_t", "deviceMask", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdDispatchBaseKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(baseGroupX, settings, "uint32_t", "baseGroupX", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(baseGroupY, settings, "uint32_t", "baseGroupY", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(baseGroupZ, settings, "uint32_t", "baseGroupZ", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(groupCountX, settings, "uint32_t", "groupCountX", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(groupCountY, settings, "uint32_t", "groupCountY", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(groupCountZ, settings, "uint32_t", "groupCountZ", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkTrimCommandPoolKHR(ApiDumpInstance& dump_inst, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkCommandPool(commandPool, settings, "VkCommandPool", "commandPool", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkCommandPoolTrimFlags(flags, settings, "VkCommandPoolTrimFlags", "flags", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkEnumeratePhysicalDeviceGroupsKHR(ApiDumpInstance& dump_inst, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkInstance(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pPhysicalDeviceGroupCount, settings, "uint32_t*", "pPhysicalDeviceGroupCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pPhysicalDeviceGroupProperties, *pPhysicalDeviceGroupCount, settings, "VkPhysicalDeviceGroupProperties*", "pPhysicalDeviceGroupProperties", "VkPhysicalDeviceGroupProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceGroupProperties); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceExternalBufferPropertiesKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pExternalBufferInfo, settings, "const VkPhysicalDeviceExternalBufferInfo*", "pExternalBufferInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceExternalBufferInfo); + dump_separate_members(settings); + dump_pointer(pExternalBufferProperties, settings, "VkExternalBufferProperties*", "pExternalBufferProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkExternalBufferProperties); + dump_post_params_formatting(settings); + flush(settings); + } +} +#if defined(VK_USE_PLATFORM_WIN32_KHR) + +template +void dump_params_vkGetMemoryWin32HandleKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pGetWin32HandleInfo, settings, "const VkMemoryGetWin32HandleInfoKHR*", "pGetWin32HandleInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryGetWin32HandleInfoKHR); + dump_separate_members(settings); + dump_pointer(pHandle, settings, "HANDLE*", "pHandle", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetMemoryWin32HandlePropertiesKHR(ApiDumpInstance& dump_inst, VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkExternalMemoryHandleTypeFlagBits(handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(handle, settings, "HANDLE", "handle", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pMemoryWin32HandleProperties, settings, "VkMemoryWin32HandlePropertiesKHR*", "pMemoryWin32HandleProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryWin32HandlePropertiesKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} +#endif // VK_USE_PLATFORM_WIN32_KHR + +template +void dump_params_vkGetMemoryFdKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pGetFdInfo, settings, "const VkMemoryGetFdInfoKHR*", "pGetFdInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryGetFdInfoKHR); + dump_separate_members(settings); + dump_pointer(pFd, settings, "int*", "pFd", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetMemoryFdPropertiesKHR(ApiDumpInstance& dump_inst, VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkExternalMemoryHandleTypeFlagBits(handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(fd, settings, "int", "fd", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pMemoryFdProperties, settings, "VkMemoryFdPropertiesKHR*", "pMemoryFdProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryFdPropertiesKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pExternalSemaphoreInfo, settings, "const VkPhysicalDeviceExternalSemaphoreInfo*", "pExternalSemaphoreInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceExternalSemaphoreInfo); + dump_separate_members(settings); + dump_pointer(pExternalSemaphoreProperties, settings, "VkExternalSemaphoreProperties*", "pExternalSemaphoreProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkExternalSemaphoreProperties); + dump_post_params_formatting(settings); + flush(settings); + } +} +#if defined(VK_USE_PLATFORM_WIN32_KHR) + +template +void dump_params_vkImportSemaphoreWin32HandleKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pImportSemaphoreWin32HandleInfo, settings, "const VkImportSemaphoreWin32HandleInfoKHR*", "pImportSemaphoreWin32HandleInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImportSemaphoreWin32HandleInfoKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetSemaphoreWin32HandleKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pGetWin32HandleInfo, settings, "const VkSemaphoreGetWin32HandleInfoKHR*", "pGetWin32HandleInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSemaphoreGetWin32HandleInfoKHR); + dump_separate_members(settings); + dump_pointer(pHandle, settings, "HANDLE*", "pHandle", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} +#endif // VK_USE_PLATFORM_WIN32_KHR + +template +void dump_params_vkImportSemaphoreFdKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pImportSemaphoreFdInfo, settings, "const VkImportSemaphoreFdInfoKHR*", "pImportSemaphoreFdInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImportSemaphoreFdInfoKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetSemaphoreFdKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pGetFdInfo, settings, "const VkSemaphoreGetFdInfoKHR*", "pGetFdInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSemaphoreGetFdInfoKHR); + dump_separate_members(settings); + dump_pointer(pFd, settings, "int*", "pFd", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdPushDescriptorSetKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipelineBindPoint(pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipelineLayout(layout, settings, "VkPipelineLayout", "layout", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(set, settings, "uint32_t", "set", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(descriptorWriteCount, settings, "uint32_t", "descriptorWriteCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pDescriptorWrites, descriptorWriteCount, settings, "const VkWriteDescriptorSet*", "pDescriptorWrites", "const VkWriteDescriptorSet", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkWriteDescriptorSet); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdPushDescriptorSetWithTemplateKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDescriptorUpdateTemplate(descriptorUpdateTemplate, settings, "VkDescriptorUpdateTemplate", "descriptorUpdateTemplate", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipelineLayout(layout, settings, "VkPipelineLayout", "layout", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(set, settings, "uint32_t", "set", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(pData, settings, "const void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateDescriptorUpdateTemplateKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkDescriptorUpdateTemplateCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorUpdateTemplateCreateInfo); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pDescriptorUpdateTemplate, settings, "VkDescriptorUpdateTemplate*", "pDescriptorUpdateTemplate", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorUpdateTemplate); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyDescriptorUpdateTemplateKHR(ApiDumpInstance& dump_inst, VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDescriptorUpdateTemplate(descriptorUpdateTemplate, settings, "VkDescriptorUpdateTemplate", "descriptorUpdateTemplate", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkUpdateDescriptorSetWithTemplateKHR(ApiDumpInstance& dump_inst, VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDescriptorSet(descriptorSet, settings, "VkDescriptorSet", "descriptorSet", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDescriptorUpdateTemplate(descriptorUpdateTemplate, settings, "VkDescriptorUpdateTemplate", "descriptorUpdateTemplate", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(pData, settings, "const void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateRenderPass2KHR(ApiDumpInstance& dump_inst, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkRenderPassCreateInfo2*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderPassCreateInfo2); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pRenderPass, settings, "VkRenderPass*", "pRenderPass", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderPass); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdBeginRenderPass2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pRenderPassBegin, settings, "const VkRenderPassBeginInfo*", "pRenderPassBegin", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderPassBeginInfo); + dump_separate_members(settings); + dump_pointer(pSubpassBeginInfo, settings, "const VkSubpassBeginInfo*", "pSubpassBeginInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSubpassBeginInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdNextSubpass2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pSubpassBeginInfo, settings, "const VkSubpassBeginInfo*", "pSubpassBeginInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSubpassBeginInfo); + dump_separate_members(settings); + dump_pointer(pSubpassEndInfo, settings, "const VkSubpassEndInfo*", "pSubpassEndInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSubpassEndInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdEndRenderPass2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pSubpassEndInfo, settings, "const VkSubpassEndInfo*", "pSubpassEndInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSubpassEndInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetSwapchainStatusKHR(ApiDumpInstance& dump_inst, VkDevice device, VkSwapchainKHR swapchain) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkSwapchainKHR(swapchain, settings, "VkSwapchainKHR", "swapchain", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceExternalFencePropertiesKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pExternalFenceInfo, settings, "const VkPhysicalDeviceExternalFenceInfo*", "pExternalFenceInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceExternalFenceInfo); + dump_separate_members(settings); + dump_pointer(pExternalFenceProperties, settings, "VkExternalFenceProperties*", "pExternalFenceProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkExternalFenceProperties); + dump_post_params_formatting(settings); + flush(settings); + } +} +#if defined(VK_USE_PLATFORM_WIN32_KHR) + +template +void dump_params_vkImportFenceWin32HandleKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pImportFenceWin32HandleInfo, settings, "const VkImportFenceWin32HandleInfoKHR*", "pImportFenceWin32HandleInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImportFenceWin32HandleInfoKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetFenceWin32HandleKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pGetWin32HandleInfo, settings, "const VkFenceGetWin32HandleInfoKHR*", "pGetWin32HandleInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkFenceGetWin32HandleInfoKHR); + dump_separate_members(settings); + dump_pointer(pHandle, settings, "HANDLE*", "pHandle", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} +#endif // VK_USE_PLATFORM_WIN32_KHR + +template +void dump_params_vkImportFenceFdKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pImportFenceFdInfo, settings, "const VkImportFenceFdInfoKHR*", "pImportFenceFdInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImportFenceFdInfoKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetFenceFdKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pGetFdInfo, settings, "const VkFenceGetFdInfoKHR*", "pGetFdInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkFenceGetFdInfoKHR); + dump_separate_members(settings); + dump_pointer(pFd, settings, "int*", "pFd", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCounterCount, settings, "uint32_t*", "pCounterCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pCounters, *pCounterCount, settings, "VkPerformanceCounterKHR*", "pCounters", "VkPerformanceCounterKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPerformanceCounterKHR); + dump_separate_members(settings); + dump_pointer_array(pCounterDescriptions, *pCounterCount, settings, "VkPerformanceCounterDescriptionKHR*", "pCounterDescriptions", "VkPerformanceCounterDescriptionKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPerformanceCounterDescriptionKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pPerformanceQueryCreateInfo, settings, "const VkQueryPoolPerformanceCreateInfoKHR*", "pPerformanceQueryCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkQueryPoolPerformanceCreateInfoKHR); + dump_separate_members(settings); + dump_pointer(pNumPasses, settings, "uint32_t*", "pNumPasses", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkAcquireProfilingLockKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkAcquireProfilingLockInfoKHR*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAcquireProfilingLockInfoKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkReleaseProfilingLockKHR(ApiDumpInstance& dump_inst, VkDevice device) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceSurfaceCapabilities2KHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pSurfaceInfo, settings, "const VkPhysicalDeviceSurfaceInfo2KHR*", "pSurfaceInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceSurfaceInfo2KHR); + dump_separate_members(settings); + dump_pointer(pSurfaceCapabilities, settings, "VkSurfaceCapabilities2KHR*", "pSurfaceCapabilities", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceCapabilities2KHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceSurfaceFormats2KHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pSurfaceInfo, settings, "const VkPhysicalDeviceSurfaceInfo2KHR*", "pSurfaceInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceSurfaceInfo2KHR); + dump_separate_members(settings); + dump_pointer(pSurfaceFormatCount, settings, "uint32_t*", "pSurfaceFormatCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pSurfaceFormats, *pSurfaceFormatCount, settings, "VkSurfaceFormat2KHR*", "pSurfaceFormats", "VkSurfaceFormat2KHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceFormat2KHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceDisplayProperties2KHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pPropertyCount, settings, "uint32_t*", "pPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pProperties, *pPropertyCount, settings, "VkDisplayProperties2KHR*", "pProperties", "VkDisplayProperties2KHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayProperties2KHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pPropertyCount, settings, "uint32_t*", "pPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pProperties, *pPropertyCount, settings, "VkDisplayPlaneProperties2KHR*", "pProperties", "VkDisplayPlaneProperties2KHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayPlaneProperties2KHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetDisplayModeProperties2KHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDisplayKHR(display, settings, "VkDisplayKHR", "display", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pPropertyCount, settings, "uint32_t*", "pPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pProperties, *pPropertyCount, settings, "VkDisplayModeProperties2KHR*", "pProperties", "VkDisplayModeProperties2KHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayModeProperties2KHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetDisplayPlaneCapabilities2KHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pDisplayPlaneInfo, settings, "const VkDisplayPlaneInfo2KHR*", "pDisplayPlaneInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayPlaneInfo2KHR); + dump_separate_members(settings); + dump_pointer(pCapabilities, settings, "VkDisplayPlaneCapabilities2KHR*", "pCapabilities", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayPlaneCapabilities2KHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetImageMemoryRequirements2KHR(ApiDumpInstance& dump_inst, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkImageMemoryRequirementsInfo2*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageMemoryRequirementsInfo2); + dump_separate_members(settings); + dump_pointer(pMemoryRequirements, settings, "VkMemoryRequirements2*", "pMemoryRequirements", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetBufferMemoryRequirements2KHR(ApiDumpInstance& dump_inst, VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkBufferMemoryRequirementsInfo2*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferMemoryRequirementsInfo2); + dump_separate_members(settings); + dump_pointer(pMemoryRequirements, settings, "VkMemoryRequirements2*", "pMemoryRequirements", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetImageSparseMemoryRequirements2KHR(ApiDumpInstance& dump_inst, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkImageSparseMemoryRequirementsInfo2*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageSparseMemoryRequirementsInfo2); + dump_separate_members(settings); + dump_pointer(pSparseMemoryRequirementCount, settings, "uint32_t*", "pSparseMemoryRequirementCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pSparseMemoryRequirements, *pSparseMemoryRequirementCount, settings, "VkSparseImageMemoryRequirements2*", "pSparseMemoryRequirements", "VkSparseImageMemoryRequirements2", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSparseImageMemoryRequirements2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateSamplerYcbcrConversionKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkSamplerYcbcrConversionCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSamplerYcbcrConversionCreateInfo); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pYcbcrConversion, settings, "VkSamplerYcbcrConversion*", "pYcbcrConversion", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSamplerYcbcrConversion); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroySamplerYcbcrConversionKHR(ApiDumpInstance& dump_inst, VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkSamplerYcbcrConversion(ycbcrConversion, settings, "VkSamplerYcbcrConversion", "ycbcrConversion", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkBindBufferMemory2KHR(ApiDumpInstance& dump_inst, VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(bindInfoCount, settings, "uint32_t", "bindInfoCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pBindInfos, bindInfoCount, settings, "const VkBindBufferMemoryInfo*", "pBindInfos", "const VkBindBufferMemoryInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBindBufferMemoryInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkBindImageMemory2KHR(ApiDumpInstance& dump_inst, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(bindInfoCount, settings, "uint32_t", "bindInfoCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pBindInfos, bindInfoCount, settings, "const VkBindImageMemoryInfo*", "pBindInfos", "const VkBindImageMemoryInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBindImageMemoryInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetDescriptorSetLayoutSupportKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkDescriptorSetLayoutCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorSetLayoutCreateInfo); + dump_separate_members(settings); + dump_pointer(pSupport, settings, "VkDescriptorSetLayoutSupport*", "pSupport", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorSetLayoutSupport); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdDrawIndirectCountKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(buffer, settings, "VkBuffer", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(offset, settings, "VkDeviceSize", "offset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(countBuffer, settings, "VkBuffer", "countBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(countBufferOffset, settings, "VkDeviceSize", "countBufferOffset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(maxDrawCount, settings, "uint32_t", "maxDrawCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(stride, settings, "uint32_t", "stride", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdDrawIndexedIndirectCountKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(buffer, settings, "VkBuffer", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(offset, settings, "VkDeviceSize", "offset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(countBuffer, settings, "VkBuffer", "countBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(countBufferOffset, settings, "VkDeviceSize", "countBufferOffset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(maxDrawCount, settings, "uint32_t", "maxDrawCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(stride, settings, "uint32_t", "stride", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetSemaphoreCounterValueKHR(ApiDumpInstance& dump_inst, VkDevice device, VkSemaphore semaphore, uint64_t* pValue) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkSemaphore(semaphore, settings, "VkSemaphore", "semaphore", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pValue, settings, "uint64_t*", "pValue", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkWaitSemaphoresKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pWaitInfo, settings, "const VkSemaphoreWaitInfo*", "pWaitInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSemaphoreWaitInfo); + dump_separate_members(settings); + dump_type(timeout, settings, "uint64_t", "timeout", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkSignalSemaphoreKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pSignalInfo, settings, "const VkSemaphoreSignalInfo*", "pSignalInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSemaphoreSignalInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceFragmentShadingRatesKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pFragmentShadingRateCount, settings, "uint32_t*", "pFragmentShadingRateCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pFragmentShadingRates, *pFragmentShadingRateCount, settings, "VkPhysicalDeviceFragmentShadingRateKHR*", "pFragmentShadingRates", "VkPhysicalDeviceFragmentShadingRateKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceFragmentShadingRateKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetFragmentShadingRateKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pFragmentSize, settings, "const VkExtent2D*", "pFragmentSize", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkExtent2D); + dump_separate_members(settings); + dump_pointer_array(combinerOps, 2, settings, "const VkFragmentShadingRateCombinerOpKHR[2]", "combinerOps", "const VkFragmentShadingRateCombinerOpKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkFragmentShadingRateCombinerOpKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetRenderingAttachmentLocationsKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkRenderingAttachmentLocationInfo* pLocationInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pLocationInfo, settings, "const VkRenderingAttachmentLocationInfo*", "pLocationInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderingAttachmentLocationInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetRenderingInputAttachmentIndicesKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInputAttachmentIndexInfo, settings, "const VkRenderingInputAttachmentIndexInfo*", "pInputAttachmentIndexInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderingInputAttachmentIndexInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkWaitForPresentKHR(ApiDumpInstance& dump_inst, VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkSwapchainKHR(swapchain, settings, "VkSwapchainKHR", "swapchain", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(presentId, settings, "uint64_t", "presentId", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(timeout, settings, "uint64_t", "timeout", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetBufferDeviceAddressKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkBufferDeviceAddressInfo* pInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkBufferDeviceAddressInfo*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferDeviceAddressInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetBufferOpaqueCaptureAddressKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkBufferDeviceAddressInfo* pInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkBufferDeviceAddressInfo*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferDeviceAddressInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetDeviceMemoryOpaqueCaptureAddressKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkDeviceMemoryOpaqueCaptureAddressInfo*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceMemoryOpaqueCaptureAddressInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateDeferredOperationKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkAllocationCallbacks* pAllocator, VkDeferredOperationKHR* pDeferredOperation) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pDeferredOperation, settings, "VkDeferredOperationKHR*", "pDeferredOperation", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeferredOperationKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyDeferredOperationKHR(ApiDumpInstance& dump_inst, VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDeferredOperationKHR(operation, settings, "VkDeferredOperationKHR", "operation", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetDeferredOperationMaxConcurrencyKHR(ApiDumpInstance& dump_inst, VkDevice device, VkDeferredOperationKHR operation) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDeferredOperationKHR(operation, settings, "VkDeferredOperationKHR", "operation", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetDeferredOperationResultKHR(ApiDumpInstance& dump_inst, VkDevice device, VkDeferredOperationKHR operation) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDeferredOperationKHR(operation, settings, "VkDeferredOperationKHR", "operation", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDeferredOperationJoinKHR(ApiDumpInstance& dump_inst, VkDevice device, VkDeferredOperationKHR operation) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDeferredOperationKHR(operation, settings, "VkDeferredOperationKHR", "operation", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPipelineExecutablePropertiesKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pPipelineInfo, settings, "const VkPipelineInfoKHR*", "pPipelineInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineInfoKHR); + dump_separate_members(settings); + dump_pointer(pExecutableCount, settings, "uint32_t*", "pExecutableCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pProperties, *pExecutableCount, settings, "VkPipelineExecutablePropertiesKHR*", "pProperties", "VkPipelineExecutablePropertiesKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineExecutablePropertiesKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPipelineExecutableStatisticsKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pExecutableInfo, settings, "const VkPipelineExecutableInfoKHR*", "pExecutableInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineExecutableInfoKHR); + dump_separate_members(settings); + dump_pointer(pStatisticCount, settings, "uint32_t*", "pStatisticCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pStatistics, *pStatisticCount, settings, "VkPipelineExecutableStatisticKHR*", "pStatistics", "VkPipelineExecutableStatisticKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineExecutableStatisticKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPipelineExecutableInternalRepresentationsKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pExecutableInfo, settings, "const VkPipelineExecutableInfoKHR*", "pExecutableInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineExecutableInfoKHR); + dump_separate_members(settings); + dump_pointer(pInternalRepresentationCount, settings, "uint32_t*", "pInternalRepresentationCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pInternalRepresentations, *pInternalRepresentationCount, settings, "VkPipelineExecutableInternalRepresentationKHR*", "pInternalRepresentations", "VkPipelineExecutableInternalRepresentationKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineExecutableInternalRepresentationKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkMapMemory2KHR(ApiDumpInstance& dump_inst, VkDevice device, const VkMemoryMapInfo* pMemoryMapInfo, void** ppData) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pMemoryMapInfo, settings, "const VkMemoryMapInfo*", "pMemoryMapInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryMapInfo); + dump_separate_members(settings); + dump_type(ppData, settings, "void**", "ppData", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkUnmapMemory2KHR(ApiDumpInstance& dump_inst, VkDevice device, const VkMemoryUnmapInfo* pMemoryUnmapInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pMemoryUnmapInfo, settings, "const VkMemoryUnmapInfo*", "pMemoryUnmapInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryUnmapInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pQualityLevelInfo, settings, "const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR*", "pQualityLevelInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR); + dump_separate_members(settings); + dump_pointer(pQualityLevelProperties, settings, "VkVideoEncodeQualityLevelPropertiesKHR*", "pQualityLevelProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoEncodeQualityLevelPropertiesKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetEncodedVideoSessionParametersKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, size_t* pDataSize, void* pData) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pVideoSessionParametersInfo, settings, "const VkVideoEncodeSessionParametersGetInfoKHR*", "pVideoSessionParametersInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoEncodeSessionParametersGetInfoKHR); + dump_separate_members(settings); + dump_pointer(pFeedbackInfo, settings, "VkVideoEncodeSessionParametersFeedbackInfoKHR*", "pFeedbackInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoEncodeSessionParametersFeedbackInfoKHR); + dump_separate_members(settings); + dump_pointer(pDataSize, settings, "size_t*", "pDataSize", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_type(pData, settings, "void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdEncodeVideoKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pEncodeInfo, settings, "const VkVideoEncodeInfoKHR*", "pEncodeInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkVideoEncodeInfoKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetEvent2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkEvent(event, settings, "VkEvent", "event", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pDependencyInfo, settings, "const VkDependencyInfo*", "pDependencyInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDependencyInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdResetEvent2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkEvent(event, settings, "VkEvent", "event", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipelineStageFlags2(stageMask, settings, "VkPipelineStageFlags2", "stageMask", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdWaitEvents2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(eventCount, settings, "uint32_t", "eventCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pEvents, eventCount, settings, "const VkEvent*", "pEvents", "const VkEvent", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkEvent); + dump_separate_members(settings); + dump_pointer_array(pDependencyInfos, eventCount, settings, "const VkDependencyInfo*", "pDependencyInfos", "const VkDependencyInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDependencyInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdPipelineBarrier2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pDependencyInfo, settings, "const VkDependencyInfo*", "pDependencyInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDependencyInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdWriteTimestamp2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipelineStageFlags2(stage, settings, "VkPipelineStageFlags2", "stage", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkQueryPool(queryPool, settings, "VkQueryPool", "queryPool", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(query, settings, "uint32_t", "query", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkQueueSubmit2KHR(ApiDumpInstance& dump_inst, VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkQueue(queue, settings, "VkQueue", "queue", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(submitCount, settings, "uint32_t", "submitCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pSubmits, submitCount, settings, "const VkSubmitInfo2*", "pSubmits", "const VkSubmitInfo2", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSubmitInfo2); + dump_separate_members(settings); + dump_VkFence(fence, settings, "VkFence", "fence", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdCopyBuffer2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCopyBufferInfo, settings, "const VkCopyBufferInfo2*", "pCopyBufferInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyBufferInfo2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdCopyImage2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCopyImageInfo, settings, "const VkCopyImageInfo2*", "pCopyImageInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyImageInfo2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdCopyBufferToImage2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCopyBufferToImageInfo, settings, "const VkCopyBufferToImageInfo2*", "pCopyBufferToImageInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyBufferToImageInfo2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdCopyImageToBuffer2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCopyImageToBufferInfo, settings, "const VkCopyImageToBufferInfo2*", "pCopyImageToBufferInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyImageToBufferInfo2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdBlitImage2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pBlitImageInfo, settings, "const VkBlitImageInfo2*", "pBlitImageInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBlitImageInfo2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdResolveImage2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pResolveImageInfo, settings, "const VkResolveImageInfo2*", "pResolveImageInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkResolveImageInfo2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdTraceRaysIndirect2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type_hex(indirectDeviceAddress, settings, "VkDeviceAddress", "indirectDeviceAddress", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetDeviceBufferMemoryRequirementsKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkDeviceBufferMemoryRequirements*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceBufferMemoryRequirements); + dump_separate_members(settings); + dump_pointer(pMemoryRequirements, settings, "VkMemoryRequirements2*", "pMemoryRequirements", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetDeviceImageMemoryRequirementsKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkDeviceImageMemoryRequirements*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceImageMemoryRequirements); + dump_separate_members(settings); + dump_pointer(pMemoryRequirements, settings, "VkMemoryRequirements2*", "pMemoryRequirements", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetDeviceImageSparseMemoryRequirementsKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkDeviceImageMemoryRequirements*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceImageMemoryRequirements); + dump_separate_members(settings); + dump_pointer(pSparseMemoryRequirementCount, settings, "uint32_t*", "pSparseMemoryRequirementCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pSparseMemoryRequirements, *pSparseMemoryRequirementCount, settings, "VkSparseImageMemoryRequirements2*", "pSparseMemoryRequirements", "VkSparseImageMemoryRequirements2", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSparseImageMemoryRequirements2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdBindIndexBuffer2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(buffer, settings, "VkBuffer", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(offset, settings, "VkDeviceSize", "offset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(size, settings, "VkDeviceSize", "size", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkIndexType(indexType, settings, "VkIndexType", "indexType", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetRenderingAreaGranularityKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkRenderingAreaInfo* pRenderingAreaInfo, VkExtent2D* pGranularity) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pRenderingAreaInfo, settings, "const VkRenderingAreaInfo*", "pRenderingAreaInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderingAreaInfo); + dump_separate_members(settings); + dump_pointer(pGranularity, settings, "VkExtent2D*", "pGranularity", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkExtent2D); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetDeviceImageSubresourceLayoutKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkDeviceImageSubresourceInfo* pInfo, VkSubresourceLayout2* pLayout) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkDeviceImageSubresourceInfo*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceImageSubresourceInfo); + dump_separate_members(settings); + dump_pointer(pLayout, settings, "VkSubresourceLayout2*", "pLayout", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSubresourceLayout2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetImageSubresourceLayout2KHR(ApiDumpInstance& dump_inst, VkDevice device, VkImage image, const VkImageSubresource2* pSubresource, VkSubresourceLayout2* pLayout) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImage(image, settings, "VkImage", "image", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pSubresource, settings, "const VkImageSubresource2*", "pSubresource", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageSubresource2); + dump_separate_members(settings); + dump_pointer(pLayout, settings, "VkSubresourceLayout2*", "pLayout", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSubresourceLayout2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkWaitForPresent2KHR(ApiDumpInstance& dump_inst, VkDevice device, VkSwapchainKHR swapchain, const VkPresentWait2InfoKHR* pPresentWait2Info) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkSwapchainKHR(swapchain, settings, "VkSwapchainKHR", "swapchain", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pPresentWait2Info, settings, "const VkPresentWait2InfoKHR*", "pPresentWait2Info", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPresentWait2InfoKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreatePipelineBinariesKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkPipelineBinaryCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineBinaryHandlesInfoKHR* pBinaries) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkPipelineBinaryCreateInfoKHR*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineBinaryCreateInfoKHR); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pBinaries, settings, "VkPipelineBinaryHandlesInfoKHR*", "pBinaries", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineBinaryHandlesInfoKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyPipelineBinaryKHR(ApiDumpInstance& dump_inst, VkDevice device, VkPipelineBinaryKHR pipelineBinary, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipelineBinaryKHR(pipelineBinary, settings, "VkPipelineBinaryKHR", "pipelineBinary", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPipelineKeyKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkPipelineCreateInfoKHR* pPipelineCreateInfo, VkPipelineBinaryKeyKHR* pPipelineKey) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pPipelineCreateInfo, settings, "const VkPipelineCreateInfoKHR*", "pPipelineCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineCreateInfoKHR); + dump_separate_members(settings); + dump_pointer(pPipelineKey, settings, "VkPipelineBinaryKeyKHR*", "pPipelineKey", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineBinaryKeyKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPipelineBinaryDataKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkPipelineBinaryDataInfoKHR* pInfo, VkPipelineBinaryKeyKHR* pPipelineBinaryKey, size_t* pPipelineBinaryDataSize, void* pPipelineBinaryData) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkPipelineBinaryDataInfoKHR*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineBinaryDataInfoKHR); + dump_separate_members(settings); + dump_pointer(pPipelineBinaryKey, settings, "VkPipelineBinaryKeyKHR*", "pPipelineBinaryKey", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineBinaryKeyKHR); + dump_separate_members(settings); + dump_pointer(pPipelineBinaryDataSize, settings, "size_t*", "pPipelineBinaryDataSize", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_type(pPipelineBinaryData, settings, "void*", "pPipelineBinaryData", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkReleaseCapturedPipelineDataKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkReleaseCapturedPipelineDataInfoKHR* pInfo, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkReleaseCapturedPipelineDataInfoKHR*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkReleaseCapturedPipelineDataInfoKHR); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkReleaseSwapchainImagesKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkReleaseSwapchainImagesInfoKHR* pReleaseInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pReleaseInfo, settings, "const VkReleaseSwapchainImagesInfoKHR*", "pReleaseInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkReleaseSwapchainImagesInfoKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesKHR* pProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pPropertyCount, settings, "uint32_t*", "pPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pProperties, *pPropertyCount, settings, "VkCooperativeMatrixPropertiesKHR*", "pProperties", "VkCooperativeMatrixPropertiesKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCooperativeMatrixPropertiesKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetLineStippleKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(lineStippleFactor, settings, "uint32_t", "lineStippleFactor", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(lineStipplePattern, settings, "uint16_t", "lineStipplePattern", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainKHR* pTimeDomains) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pTimeDomainCount, settings, "uint32_t*", "pTimeDomainCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pTimeDomains, *pTimeDomainCount, settings, "VkTimeDomainKHR*", "pTimeDomains", "VkTimeDomainKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkTimeDomainKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetCalibratedTimestampsKHR(ApiDumpInstance& dump_inst, VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(timestampCount, settings, "uint32_t", "timestampCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pTimestampInfos, timestampCount, settings, "const VkCalibratedTimestampInfoKHR*", "pTimestampInfos", "const VkCalibratedTimestampInfoKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCalibratedTimestampInfoKHR); + dump_separate_members(settings); + dump_pointer_array(pTimestamps, timestampCount, settings, "uint64_t*", "pTimestamps", "uint64_t", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer(pMaxDeviation, settings, "uint64_t*", "pMaxDeviation", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdBindDescriptorSets2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pBindDescriptorSetsInfo, settings, "const VkBindDescriptorSetsInfo*", "pBindDescriptorSetsInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBindDescriptorSetsInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdPushConstants2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkPushConstantsInfo* pPushConstantsInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pPushConstantsInfo, settings, "const VkPushConstantsInfo*", "pPushConstantsInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPushConstantsInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdPushDescriptorSet2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfo* pPushDescriptorSetInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pPushDescriptorSetInfo, settings, "const VkPushDescriptorSetInfo*", "pPushDescriptorSetInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPushDescriptorSetInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdPushDescriptorSetWithTemplate2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pPushDescriptorSetWithTemplateInfo, settings, "const VkPushDescriptorSetWithTemplateInfo*", "pPushDescriptorSetWithTemplateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPushDescriptorSetWithTemplateInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetDescriptorBufferOffsets2EXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pSetDescriptorBufferOffsetsInfo, settings, "const VkSetDescriptorBufferOffsetsInfoEXT*", "pSetDescriptorBufferOffsetsInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSetDescriptorBufferOffsetsInfoEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pBindDescriptorBufferEmbeddedSamplersInfo, settings, "const VkBindDescriptorBufferEmbeddedSamplersInfoEXT*", "pBindDescriptorBufferEmbeddedSamplersInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBindDescriptorBufferEmbeddedSamplersInfoEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdCopyMemoryIndirectKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyMemoryIndirectInfoKHR* pCopyMemoryIndirectInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCopyMemoryIndirectInfo, settings, "const VkCopyMemoryIndirectInfoKHR*", "pCopyMemoryIndirectInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyMemoryIndirectInfoKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdCopyMemoryToImageIndirectKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyMemoryToImageIndirectInfoKHR* pCopyMemoryToImageIndirectInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCopyMemoryToImageIndirectInfo, settings, "const VkCopyMemoryToImageIndirectInfoKHR*", "pCopyMemoryToImageIndirectInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyMemoryToImageIndirectInfoKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdEndRendering2KHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkRenderingEndInfoKHR* pRenderingEndInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pRenderingEndInfo, settings, "const VkRenderingEndInfoKHR*", "pRenderingEndInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderingEndInfoKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateDebugReportCallbackEXT(ApiDumpInstance& dump_inst, VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkInstance(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkDebugReportCallbackCreateInfoEXT*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugReportCallbackCreateInfoEXT); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pCallback, settings, "VkDebugReportCallbackEXT*", "pCallback", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugReportCallbackEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyDebugReportCallbackEXT(ApiDumpInstance& dump_inst, VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkInstance(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDebugReportCallbackEXT(callback, settings, "VkDebugReportCallbackEXT", "callback", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDebugReportMessageEXT(ApiDumpInstance& dump_inst, VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkInstance(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDebugReportFlagsEXT(flags, settings, "VkDebugReportFlagsEXT", "flags", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDebugReportObjectTypeEXT(objectType, settings, "VkDebugReportObjectTypeEXT", "objectType", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(object, settings, "uint64_t", "object", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(location, settings, "size_t", "location", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(messageCode, settings, "int32_t", "messageCode", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_char(pLayerPrefix, settings, "const char*", "pLayerPrefix", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_char(pMessage, settings, "const char*", "pMessage", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDebugMarkerSetObjectTagEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pTagInfo, settings, "const VkDebugMarkerObjectTagInfoEXT*", "pTagInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugMarkerObjectTagInfoEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDebugMarkerSetObjectNameEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pNameInfo, settings, "const VkDebugMarkerObjectNameInfoEXT*", "pNameInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugMarkerObjectNameInfoEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdDebugMarkerBeginEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pMarkerInfo, settings, "const VkDebugMarkerMarkerInfoEXT*", "pMarkerInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugMarkerMarkerInfoEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdDebugMarkerEndEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdDebugMarkerInsertEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pMarkerInfo, settings, "const VkDebugMarkerMarkerInfoEXT*", "pMarkerInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugMarkerMarkerInfoEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdBindTransformFeedbackBuffersEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(firstBinding, settings, "uint32_t", "firstBinding", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(bindingCount, settings, "uint32_t", "bindingCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pBuffers, bindingCount, settings, "const VkBuffer*", "pBuffers", "const VkBuffer", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBuffer); + dump_separate_members(settings); + dump_pointer_array(pOffsets, bindingCount, settings, "const VkDeviceSize*", "pOffsets", "const VkDeviceSize", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pSizes, bindingCount, settings, "const VkDeviceSize*", "pSizes", "const VkDeviceSize", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdBeginTransformFeedbackEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(firstCounterBuffer, settings, "uint32_t", "firstCounterBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(counterBufferCount, settings, "uint32_t", "counterBufferCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pCounterBuffers, counterBufferCount, settings, "const VkBuffer*", "pCounterBuffers", "const VkBuffer", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBuffer); + dump_separate_members(settings); + dump_pointer_array(pCounterBufferOffsets, counterBufferCount, settings, "const VkDeviceSize*", "pCounterBufferOffsets", "const VkDeviceSize", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdEndTransformFeedbackEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(firstCounterBuffer, settings, "uint32_t", "firstCounterBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(counterBufferCount, settings, "uint32_t", "counterBufferCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pCounterBuffers, counterBufferCount, settings, "const VkBuffer*", "pCounterBuffers", "const VkBuffer", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBuffer); + dump_separate_members(settings); + dump_pointer_array(pCounterBufferOffsets, counterBufferCount, settings, "const VkDeviceSize*", "pCounterBufferOffsets", "const VkDeviceSize", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdBeginQueryIndexedEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkQueryPool(queryPool, settings, "VkQueryPool", "queryPool", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(query, settings, "uint32_t", "query", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkQueryControlFlags(flags, settings, "VkQueryControlFlags", "flags", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(index, settings, "uint32_t", "index", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdEndQueryIndexedEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkQueryPool(queryPool, settings, "VkQueryPool", "queryPool", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(query, settings, "uint32_t", "query", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(index, settings, "uint32_t", "index", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdDrawIndirectByteCountEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(instanceCount, settings, "uint32_t", "instanceCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(firstInstance, settings, "uint32_t", "firstInstance", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(counterBuffer, settings, "VkBuffer", "counterBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(counterBufferOffset, settings, "VkDeviceSize", "counterBufferOffset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(counterOffset, settings, "uint32_t", "counterOffset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(vertexStride, settings, "uint32_t", "vertexStride", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateCuModuleNVX(ApiDumpInstance& dump_inst, VkDevice device, const VkCuModuleCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuModuleNVX* pModule) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkCuModuleCreateInfoNVX*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCuModuleCreateInfoNVX); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pModule, settings, "VkCuModuleNVX*", "pModule", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCuModuleNVX); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateCuFunctionNVX(ApiDumpInstance& dump_inst, VkDevice device, const VkCuFunctionCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuFunctionNVX* pFunction) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkCuFunctionCreateInfoNVX*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCuFunctionCreateInfoNVX); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pFunction, settings, "VkCuFunctionNVX*", "pFunction", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCuFunctionNVX); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyCuModuleNVX(ApiDumpInstance& dump_inst, VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkCuModuleNVX(module, settings, "VkCuModuleNVX", "module", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyCuFunctionNVX(ApiDumpInstance& dump_inst, VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkCuFunctionNVX(function, settings, "VkCuFunctionNVX", "function", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdCuLaunchKernelNVX(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pLaunchInfo, settings, "const VkCuLaunchInfoNVX*", "pLaunchInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCuLaunchInfoNVX); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetImageViewHandleNVX(ApiDumpInstance& dump_inst, VkDevice device, const VkImageViewHandleInfoNVX* pInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkImageViewHandleInfoNVX*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageViewHandleInfoNVX); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetImageViewHandle64NVX(ApiDumpInstance& dump_inst, VkDevice device, const VkImageViewHandleInfoNVX* pInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkImageViewHandleInfoNVX*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageViewHandleInfoNVX); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetImageViewAddressNVX(ApiDumpInstance& dump_inst, VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX* pProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImageView(imageView, settings, "VkImageView", "imageView", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pProperties, settings, "VkImageViewAddressPropertiesNVX*", "pProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageViewAddressPropertiesNVX); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetDeviceCombinedImageSamplerIndexNVX(ApiDumpInstance& dump_inst, VkDevice device, uint64_t imageViewIndex, uint64_t samplerIndex) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(imageViewIndex, settings, "uint64_t", "imageViewIndex", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(samplerIndex, settings, "uint64_t", "samplerIndex", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdDrawIndirectCountAMD(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(buffer, settings, "VkBuffer", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(offset, settings, "VkDeviceSize", "offset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(countBuffer, settings, "VkBuffer", "countBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(countBufferOffset, settings, "VkDeviceSize", "countBufferOffset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(maxDrawCount, settings, "uint32_t", "maxDrawCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(stride, settings, "uint32_t", "stride", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdDrawIndexedIndirectCountAMD(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(buffer, settings, "VkBuffer", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(offset, settings, "VkDeviceSize", "offset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(countBuffer, settings, "VkBuffer", "countBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(countBufferOffset, settings, "VkDeviceSize", "countBufferOffset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(maxDrawCount, settings, "uint32_t", "maxDrawCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(stride, settings, "uint32_t", "stride", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetShaderInfoAMD(ApiDumpInstance& dump_inst, VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipeline(pipeline, settings, "VkPipeline", "pipeline", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkShaderStageFlagBits(shaderStage, settings, "VkShaderStageFlagBits", "shaderStage", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkShaderInfoTypeAMD(infoType, settings, "VkShaderInfoTypeAMD", "infoType", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfoSize, settings, "size_t*", "pInfoSize", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_type(pInfo, settings, "void*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} +#if defined(VK_USE_PLATFORM_GGP) + +template +void dump_params_vkCreateStreamDescriptorSurfaceGGP(ApiDumpInstance& dump_inst, VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkInstance(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkStreamDescriptorSurfaceCreateInfoGGP*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkStreamDescriptorSurfaceCreateInfoGGP); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pSurface, settings, "VkSurfaceKHR*", "pSurface", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} +#endif // VK_USE_PLATFORM_GGP + +template +void dump_params_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkFormat(format, settings, "VkFormat", "format", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImageType(type, settings, "VkImageType", "type", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImageTiling(tiling, settings, "VkImageTiling", "tiling", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImageUsageFlags(usage, settings, "VkImageUsageFlags", "usage", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImageCreateFlags(flags, settings, "VkImageCreateFlags", "flags", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkExternalMemoryHandleTypeFlagsNV(externalHandleType, settings, "VkExternalMemoryHandleTypeFlagsNV", "externalHandleType", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pExternalImageFormatProperties, settings, "VkExternalImageFormatPropertiesNV*", "pExternalImageFormatProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkExternalImageFormatPropertiesNV); + dump_post_params_formatting(settings); + flush(settings); + } +} +#if defined(VK_USE_PLATFORM_WIN32_KHR) + +template +void dump_params_vkGetMemoryWin32HandleNV(ApiDumpInstance& dump_inst, VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDeviceMemory(memory, settings, "VkDeviceMemory", "memory", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkExternalMemoryHandleTypeFlagsNV(handleType, settings, "VkExternalMemoryHandleTypeFlagsNV", "handleType", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pHandle, settings, "HANDLE*", "pHandle", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} +#endif // VK_USE_PLATFORM_WIN32_KHR +#if defined(VK_USE_PLATFORM_VI_NN) + +template +void dump_params_vkCreateViSurfaceNN(ApiDumpInstance& dump_inst, VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkInstance(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkViSurfaceCreateInfoNN*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkViSurfaceCreateInfoNN); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pSurface, settings, "VkSurfaceKHR*", "pSurface", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} +#endif // VK_USE_PLATFORM_VI_NN + +template +void dump_params_vkCmdBeginConditionalRenderingEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pConditionalRenderingBegin, settings, "const VkConditionalRenderingBeginInfoEXT*", "pConditionalRenderingBegin", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkConditionalRenderingBeginInfoEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdEndConditionalRenderingEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetViewportWScalingNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(firstViewport, settings, "uint32_t", "firstViewport", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(viewportCount, settings, "uint32_t", "viewportCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pViewportWScalings, viewportCount, settings, "const VkViewportWScalingNV*", "pViewportWScalings", "const VkViewportWScalingNV", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkViewportWScalingNV); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkReleaseDisplayEXT(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkDisplayKHR display) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDisplayKHR(display, settings, "VkDisplayKHR", "display", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} +#if defined(VK_USE_PLATFORM_XLIB_XRANDR_EXT) + +template +void dump_params_vkAcquireXlibDisplayEXT(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(dpy, settings, "Display*", "dpy", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDisplayKHR(display, settings, "VkDisplayKHR", "display", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetRandROutputDisplayEXT(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(dpy, settings, "Display*", "dpy", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(rrOutput, settings, "RROutput", "rrOutput", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pDisplay, settings, "VkDisplayKHR*", "pDisplay", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} +#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT + +template +void dump_params_vkGetPhysicalDeviceSurfaceCapabilities2EXT(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkSurfaceKHR(surface, settings, "VkSurfaceKHR", "surface", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pSurfaceCapabilities, settings, "VkSurfaceCapabilities2EXT*", "pSurfaceCapabilities", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceCapabilities2EXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDisplayPowerControlEXT(ApiDumpInstance& dump_inst, VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDisplayKHR(display, settings, "VkDisplayKHR", "display", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pDisplayPowerInfo, settings, "const VkDisplayPowerInfoEXT*", "pDisplayPowerInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayPowerInfoEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkRegisterDeviceEventEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pDeviceEventInfo, settings, "const VkDeviceEventInfoEXT*", "pDeviceEventInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceEventInfoEXT); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pFence, settings, "VkFence*", "pFence", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkFence); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkRegisterDisplayEventEXT(ApiDumpInstance& dump_inst, VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDisplayKHR(display, settings, "VkDisplayKHR", "display", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pDisplayEventInfo, settings, "const VkDisplayEventInfoEXT*", "pDisplayEventInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayEventInfoEXT); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pFence, settings, "VkFence*", "pFence", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkFence); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetSwapchainCounterEXT(ApiDumpInstance& dump_inst, VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkSwapchainKHR(swapchain, settings, "VkSwapchainKHR", "swapchain", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkSurfaceCounterFlagBitsEXT(counter, settings, "VkSurfaceCounterFlagBitsEXT", "counter", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCounterValue, settings, "uint64_t*", "pCounterValue", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetRefreshCycleDurationGOOGLE(ApiDumpInstance& dump_inst, VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkSwapchainKHR(swapchain, settings, "VkSwapchainKHR", "swapchain", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pDisplayTimingProperties, settings, "VkRefreshCycleDurationGOOGLE*", "pDisplayTimingProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRefreshCycleDurationGOOGLE); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPastPresentationTimingGOOGLE(ApiDumpInstance& dump_inst, VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkSwapchainKHR(swapchain, settings, "VkSwapchainKHR", "swapchain", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pPresentationTimingCount, settings, "uint32_t*", "pPresentationTimingCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pPresentationTimings, *pPresentationTimingCount, settings, "VkPastPresentationTimingGOOGLE*", "pPresentationTimings", "VkPastPresentationTimingGOOGLE", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPastPresentationTimingGOOGLE); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetDiscardRectangleEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(firstDiscardRectangle, settings, "uint32_t", "firstDiscardRectangle", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(discardRectangleCount, settings, "uint32_t", "discardRectangleCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pDiscardRectangles, discardRectangleCount, settings, "const VkRect2D*", "pDiscardRectangles", "const VkRect2D", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRect2D); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetDiscardRectangleEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(discardRectangleEnable, settings, "VkBool32", "discardRectangleEnable", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetDiscardRectangleModeEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDiscardRectangleModeEXT(discardRectangleMode, settings, "VkDiscardRectangleModeEXT", "discardRectangleMode", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkSetHdrMetadataEXT(ApiDumpInstance& dump_inst, VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(swapchainCount, settings, "uint32_t", "swapchainCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pSwapchains, swapchainCount, settings, "const VkSwapchainKHR*", "pSwapchains", "const VkSwapchainKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSwapchainKHR); + dump_separate_members(settings); + dump_pointer_array(pMetadata, swapchainCount, settings, "const VkHdrMetadataEXT*", "pMetadata", "const VkHdrMetadataEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkHdrMetadataEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} +#if defined(VK_USE_PLATFORM_IOS_MVK) + +template +void dump_params_vkCreateIOSSurfaceMVK(ApiDumpInstance& dump_inst, VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkInstance(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkIOSSurfaceCreateInfoMVK*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkIOSSurfaceCreateInfoMVK); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pSurface, settings, "VkSurfaceKHR*", "pSurface", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} +#endif // VK_USE_PLATFORM_IOS_MVK +#if defined(VK_USE_PLATFORM_MACOS_MVK) + +template +void dump_params_vkCreateMacOSSurfaceMVK(ApiDumpInstance& dump_inst, VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkInstance(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkMacOSSurfaceCreateInfoMVK*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMacOSSurfaceCreateInfoMVK); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pSurface, settings, "VkSurfaceKHR*", "pSurface", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} +#endif // VK_USE_PLATFORM_MACOS_MVK + +template +void dump_params_vkSetDebugUtilsObjectNameEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pNameInfo, settings, "const VkDebugUtilsObjectNameInfoEXT*", "pNameInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugUtilsObjectNameInfoEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkSetDebugUtilsObjectTagEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pTagInfo, settings, "const VkDebugUtilsObjectTagInfoEXT*", "pTagInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugUtilsObjectTagInfoEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkQueueBeginDebugUtilsLabelEXT(ApiDumpInstance& dump_inst, VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkQueue(queue, settings, "VkQueue", "queue", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pLabelInfo, settings, "const VkDebugUtilsLabelEXT*", "pLabelInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugUtilsLabelEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkQueueEndDebugUtilsLabelEXT(ApiDumpInstance& dump_inst, VkQueue queue) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkQueue(queue, settings, "VkQueue", "queue", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkQueueInsertDebugUtilsLabelEXT(ApiDumpInstance& dump_inst, VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkQueue(queue, settings, "VkQueue", "queue", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pLabelInfo, settings, "const VkDebugUtilsLabelEXT*", "pLabelInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugUtilsLabelEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdBeginDebugUtilsLabelEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pLabelInfo, settings, "const VkDebugUtilsLabelEXT*", "pLabelInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugUtilsLabelEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdEndDebugUtilsLabelEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdInsertDebugUtilsLabelEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pLabelInfo, settings, "const VkDebugUtilsLabelEXT*", "pLabelInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugUtilsLabelEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateDebugUtilsMessengerEXT(ApiDumpInstance& dump_inst, VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkInstance(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkDebugUtilsMessengerCreateInfoEXT*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugUtilsMessengerCreateInfoEXT); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pMessenger, settings, "VkDebugUtilsMessengerEXT*", "pMessenger", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugUtilsMessengerEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyDebugUtilsMessengerEXT(ApiDumpInstance& dump_inst, VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkInstance(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDebugUtilsMessengerEXT(messenger, settings, "VkDebugUtilsMessengerEXT", "messenger", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkSubmitDebugUtilsMessageEXT(ApiDumpInstance& dump_inst, VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkInstance(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDebugUtilsMessageSeverityFlagBitsEXT(messageSeverity, settings, "VkDebugUtilsMessageSeverityFlagBitsEXT", "messageSeverity", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDebugUtilsMessageTypeFlagsEXT(messageTypes, settings, "VkDebugUtilsMessageTypeFlagsEXT", "messageTypes", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCallbackData, settings, "const VkDebugUtilsMessengerCallbackDataEXT*", "pCallbackData", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDebugUtilsMessengerCallbackDataEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} +#if defined(VK_USE_PLATFORM_ANDROID_KHR) + +template +void dump_params_vkGetAndroidHardwareBufferPropertiesANDROID(ApiDumpInstance& dump_inst, VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(buffer, settings, "const struct AHardwareBuffer*", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pProperties, settings, "VkAndroidHardwareBufferPropertiesANDROID*", "pProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAndroidHardwareBufferPropertiesANDROID); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetMemoryAndroidHardwareBufferANDROID(ApiDumpInstance& dump_inst, VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkMemoryGetAndroidHardwareBufferInfoANDROID*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryGetAndroidHardwareBufferInfoANDROID); + dump_separate_members(settings); + dump_type(pBuffer, settings, "struct AHardwareBuffer**", "pBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} +#endif // VK_USE_PLATFORM_ANDROID_KHR +#if defined(VK_ENABLE_BETA_EXTENSIONS) + +template +void dump_params_vkCreateExecutionGraphPipelinesAMDX(ApiDumpInstance& dump_inst, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkExecutionGraphPipelineCreateInfoAMDX* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipelineCache(pipelineCache, settings, "VkPipelineCache", "pipelineCache", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(createInfoCount, settings, "uint32_t", "createInfoCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pCreateInfos, createInfoCount, settings, "const VkExecutionGraphPipelineCreateInfoAMDX*", "pCreateInfos", "const VkExecutionGraphPipelineCreateInfoAMDX", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkExecutionGraphPipelineCreateInfoAMDX); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer_array(pPipelines, createInfoCount, settings, "VkPipeline*", "pPipelines", "VkPipeline", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipeline); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetExecutionGraphPipelineScratchSizeAMDX(ApiDumpInstance& dump_inst, VkDevice device, VkPipeline executionGraph, VkExecutionGraphPipelineScratchSizeAMDX* pSizeInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipeline(executionGraph, settings, "VkPipeline", "executionGraph", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pSizeInfo, settings, "VkExecutionGraphPipelineScratchSizeAMDX*", "pSizeInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkExecutionGraphPipelineScratchSizeAMDX); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetExecutionGraphPipelineNodeIndexAMDX(ApiDumpInstance& dump_inst, VkDevice device, VkPipeline executionGraph, const VkPipelineShaderStageNodeCreateInfoAMDX* pNodeInfo, uint32_t* pNodeIndex) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipeline(executionGraph, settings, "VkPipeline", "executionGraph", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pNodeInfo, settings, "const VkPipelineShaderStageNodeCreateInfoAMDX*", "pNodeInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineShaderStageNodeCreateInfoAMDX); + dump_separate_members(settings); + dump_pointer(pNodeIndex, settings, "uint32_t*", "pNodeIndex", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdInitializeGraphScratchMemoryAMDX(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipeline executionGraph, VkDeviceAddress scratch, VkDeviceSize scratchSize) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipeline(executionGraph, settings, "VkPipeline", "executionGraph", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type_hex(scratch, settings, "VkDeviceAddress", "scratch", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(scratchSize, settings, "VkDeviceSize", "scratchSize", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdDispatchGraphAMDX(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkDeviceAddress scratch, VkDeviceSize scratchSize, const VkDispatchGraphCountInfoAMDX* pCountInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type_hex(scratch, settings, "VkDeviceAddress", "scratch", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(scratchSize, settings, "VkDeviceSize", "scratchSize", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCountInfo, settings, "const VkDispatchGraphCountInfoAMDX*", "pCountInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDispatchGraphCountInfoAMDX); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdDispatchGraphIndirectAMDX(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkDeviceAddress scratch, VkDeviceSize scratchSize, const VkDispatchGraphCountInfoAMDX* pCountInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type_hex(scratch, settings, "VkDeviceAddress", "scratch", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(scratchSize, settings, "VkDeviceSize", "scratchSize", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCountInfo, settings, "const VkDispatchGraphCountInfoAMDX*", "pCountInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDispatchGraphCountInfoAMDX); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdDispatchGraphIndirectCountAMDX(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkDeviceAddress scratch, VkDeviceSize scratchSize, VkDeviceAddress countInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type_hex(scratch, settings, "VkDeviceAddress", "scratch", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(scratchSize, settings, "VkDeviceSize", "scratchSize", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type_hex(countInfo, settings, "VkDeviceAddress", "countInfo", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} +#endif // VK_ENABLE_BETA_EXTENSIONS + +template +void dump_params_vkWriteSamplerDescriptorsEXT(ApiDumpInstance& dump_inst, VkDevice device, uint32_t samplerCount, const VkSamplerCreateInfo* pSamplers, const VkHostAddressRangeEXT* pDescriptors) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(samplerCount, settings, "uint32_t", "samplerCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pSamplers, samplerCount, settings, "const VkSamplerCreateInfo*", "pSamplers", "const VkSamplerCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSamplerCreateInfo); + dump_separate_members(settings); + dump_pointer_array(pDescriptors, samplerCount, settings, "const VkHostAddressRangeEXT*", "pDescriptors", "const VkHostAddressRangeEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkHostAddressRangeEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkWriteResourceDescriptorsEXT(ApiDumpInstance& dump_inst, VkDevice device, uint32_t resourceCount, const VkResourceDescriptorInfoEXT* pResources, const VkHostAddressRangeEXT* pDescriptors) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(resourceCount, settings, "uint32_t", "resourceCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pResources, resourceCount, settings, "const VkResourceDescriptorInfoEXT*", "pResources", "const VkResourceDescriptorInfoEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkResourceDescriptorInfoEXT); + dump_separate_members(settings); + dump_pointer_array(pDescriptors, resourceCount, settings, "const VkHostAddressRangeEXT*", "pDescriptors", "const VkHostAddressRangeEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkHostAddressRangeEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdBindSamplerHeapEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkBindHeapInfoEXT* pBindInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pBindInfo, settings, "const VkBindHeapInfoEXT*", "pBindInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBindHeapInfoEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdBindResourceHeapEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkBindHeapInfoEXT* pBindInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pBindInfo, settings, "const VkBindHeapInfoEXT*", "pBindInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBindHeapInfoEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdPushDataEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkPushDataInfoEXT* pPushDataInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pPushDataInfo, settings, "const VkPushDataInfoEXT*", "pPushDataInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPushDataInfoEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetImageOpaqueCaptureDataEXT(ApiDumpInstance& dump_inst, VkDevice device, uint32_t imageCount, const VkImage* pImages, VkHostAddressRangeEXT* pDatas) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(imageCount, settings, "uint32_t", "imageCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pImages, imageCount, settings, "const VkImage*", "pImages", "const VkImage", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImage); + dump_separate_members(settings); + dump_pointer_array(pDatas, imageCount, settings, "VkHostAddressRangeEXT*", "pDatas", "VkHostAddressRangeEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkHostAddressRangeEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceDescriptorSizeEXT(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkDescriptorType descriptorType) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDescriptorType(descriptorType, settings, "VkDescriptorType", "descriptorType", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkRegisterCustomBorderColorEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkSamplerCustomBorderColorCreateInfoEXT* pBorderColor, VkBool32 requestIndex, uint32_t* pIndex) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pBorderColor, settings, "const VkSamplerCustomBorderColorCreateInfoEXT*", "pBorderColor", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSamplerCustomBorderColorCreateInfoEXT); + dump_separate_members(settings); + dump_type(requestIndex, settings, "VkBool32", "requestIndex", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pIndex, settings, "uint32_t*", "pIndex", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkUnregisterCustomBorderColorEXT(ApiDumpInstance& dump_inst, VkDevice device, uint32_t index) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(index, settings, "uint32_t", "index", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetTensorOpaqueCaptureDataARM(ApiDumpInstance& dump_inst, VkDevice device, uint32_t tensorCount, const VkTensorARM* pTensors, VkHostAddressRangeEXT* pDatas) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(tensorCount, settings, "uint32_t", "tensorCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pTensors, tensorCount, settings, "const VkTensorARM*", "pTensors", "const VkTensorARM", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkTensorARM); + dump_separate_members(settings); + dump_pointer_array(pDatas, tensorCount, settings, "VkHostAddressRangeEXT*", "pDatas", "VkHostAddressRangeEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkHostAddressRangeEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetSampleLocationsEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pSampleLocationsInfo, settings, "const VkSampleLocationsInfoEXT*", "pSampleLocationsInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSampleLocationsInfoEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceMultisamplePropertiesEXT(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkSampleCountFlagBits(samples, settings, "VkSampleCountFlagBits", "samples", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pMultisampleProperties, settings, "VkMultisamplePropertiesEXT*", "pMultisampleProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMultisamplePropertiesEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetImageDrmFormatModifierPropertiesEXT(ApiDumpInstance& dump_inst, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImage(image, settings, "VkImage", "image", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pProperties, settings, "VkImageDrmFormatModifierPropertiesEXT*", "pProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageDrmFormatModifierPropertiesEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateValidationCacheEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkValidationCacheCreateInfoEXT*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkValidationCacheCreateInfoEXT); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pValidationCache, settings, "VkValidationCacheEXT*", "pValidationCache", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkValidationCacheEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyValidationCacheEXT(ApiDumpInstance& dump_inst, VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkValidationCacheEXT(validationCache, settings, "VkValidationCacheEXT", "validationCache", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkMergeValidationCachesEXT(ApiDumpInstance& dump_inst, VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkValidationCacheEXT(dstCache, settings, "VkValidationCacheEXT", "dstCache", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(srcCacheCount, settings, "uint32_t", "srcCacheCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pSrcCaches, srcCacheCount, settings, "const VkValidationCacheEXT*", "pSrcCaches", "const VkValidationCacheEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkValidationCacheEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetValidationCacheDataEXT(ApiDumpInstance& dump_inst, VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkValidationCacheEXT(validationCache, settings, "VkValidationCacheEXT", "validationCache", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pDataSize, settings, "size_t*", "pDataSize", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_type(pData, settings, "void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdBindShadingRateImageNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImageView(imageView, settings, "VkImageView", "imageView", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(imageLayout, settings, "VkImageLayout", "imageLayout", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetViewportShadingRatePaletteNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(firstViewport, settings, "uint32_t", "firstViewport", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(viewportCount, settings, "uint32_t", "viewportCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pShadingRatePalettes, viewportCount, settings, "const VkShadingRatePaletteNV*", "pShadingRatePalettes", "const VkShadingRatePaletteNV", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkShadingRatePaletteNV); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetCoarseSampleOrderNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkCoarseSampleOrderTypeNV(sampleOrderType, settings, "VkCoarseSampleOrderTypeNV", "sampleOrderType", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(customSampleOrderCount, settings, "uint32_t", "customSampleOrderCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pCustomSampleOrders, customSampleOrderCount, settings, "const VkCoarseSampleOrderCustomNV*", "pCustomSampleOrders", "const VkCoarseSampleOrderCustomNV", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCoarseSampleOrderCustomNV); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateAccelerationStructureNV(ApiDumpInstance& dump_inst, VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkAccelerationStructureCreateInfoNV*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureCreateInfoNV); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pAccelerationStructure, settings, "VkAccelerationStructureNV*", "pAccelerationStructure", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureNV); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyAccelerationStructureNV(ApiDumpInstance& dump_inst, VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkAccelerationStructureNV(accelerationStructure, settings, "VkAccelerationStructureNV", "accelerationStructure", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetAccelerationStructureMemoryRequirementsNV(ApiDumpInstance& dump_inst, VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkAccelerationStructureMemoryRequirementsInfoNV*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureMemoryRequirementsInfoNV); + dump_separate_members(settings); + dump_pointer(pMemoryRequirements, settings, "VkMemoryRequirements2KHR*", "pMemoryRequirements", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkBindAccelerationStructureMemoryNV(ApiDumpInstance& dump_inst, VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(bindInfoCount, settings, "uint32_t", "bindInfoCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pBindInfos, bindInfoCount, settings, "const VkBindAccelerationStructureMemoryInfoNV*", "pBindInfos", "const VkBindAccelerationStructureMemoryInfoNV", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBindAccelerationStructureMemoryInfoNV); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdBuildAccelerationStructureNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkAccelerationStructureInfoNV*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureInfoNV); + dump_separate_members(settings); + dump_VkBuffer(instanceData, settings, "VkBuffer", "instanceData", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(instanceOffset, settings, "VkDeviceSize", "instanceOffset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(update, settings, "VkBool32", "update", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkAccelerationStructureNV(dst, settings, "VkAccelerationStructureNV", "dst", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkAccelerationStructureNV(src, settings, "VkAccelerationStructureNV", "src", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(scratch, settings, "VkBuffer", "scratch", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(scratchOffset, settings, "VkDeviceSize", "scratchOffset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdCopyAccelerationStructureNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkAccelerationStructureNV(dst, settings, "VkAccelerationStructureNV", "dst", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkAccelerationStructureNV(src, settings, "VkAccelerationStructureNV", "src", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkCopyAccelerationStructureModeKHR(mode, settings, "VkCopyAccelerationStructureModeKHR", "mode", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdTraceRaysNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(raygenShaderBindingTableBuffer, settings, "VkBuffer", "raygenShaderBindingTableBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(raygenShaderBindingOffset, settings, "VkDeviceSize", "raygenShaderBindingOffset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(missShaderBindingTableBuffer, settings, "VkBuffer", "missShaderBindingTableBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(missShaderBindingOffset, settings, "VkDeviceSize", "missShaderBindingOffset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(missShaderBindingStride, settings, "VkDeviceSize", "missShaderBindingStride", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(hitShaderBindingTableBuffer, settings, "VkBuffer", "hitShaderBindingTableBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(hitShaderBindingOffset, settings, "VkDeviceSize", "hitShaderBindingOffset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(hitShaderBindingStride, settings, "VkDeviceSize", "hitShaderBindingStride", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(callableShaderBindingTableBuffer, settings, "VkBuffer", "callableShaderBindingTableBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(callableShaderBindingOffset, settings, "VkDeviceSize", "callableShaderBindingOffset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(callableShaderBindingStride, settings, "VkDeviceSize", "callableShaderBindingStride", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(width, settings, "uint32_t", "width", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(height, settings, "uint32_t", "height", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(depth, settings, "uint32_t", "depth", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateRayTracingPipelinesNV(ApiDumpInstance& dump_inst, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipelineCache(pipelineCache, settings, "VkPipelineCache", "pipelineCache", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(createInfoCount, settings, "uint32_t", "createInfoCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pCreateInfos, createInfoCount, settings, "const VkRayTracingPipelineCreateInfoNV*", "pCreateInfos", "const VkRayTracingPipelineCreateInfoNV", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRayTracingPipelineCreateInfoNV); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer_array(pPipelines, createInfoCount, settings, "VkPipeline*", "pPipelines", "VkPipeline", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipeline); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetRayTracingShaderGroupHandlesKHR(ApiDumpInstance& dump_inst, VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipeline(pipeline, settings, "VkPipeline", "pipeline", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(firstGroup, settings, "uint32_t", "firstGroup", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(groupCount, settings, "uint32_t", "groupCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(dataSize, settings, "size_t", "dataSize", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(pData, settings, "void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetRayTracingShaderGroupHandlesNV(ApiDumpInstance& dump_inst, VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipeline(pipeline, settings, "VkPipeline", "pipeline", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(firstGroup, settings, "uint32_t", "firstGroup", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(groupCount, settings, "uint32_t", "groupCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(dataSize, settings, "size_t", "dataSize", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(pData, settings, "void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetAccelerationStructureHandleNV(ApiDumpInstance& dump_inst, VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkAccelerationStructureNV(accelerationStructure, settings, "VkAccelerationStructureNV", "accelerationStructure", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(dataSize, settings, "size_t", "dataSize", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(pData, settings, "void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdWriteAccelerationStructuresPropertiesNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(accelerationStructureCount, settings, "uint32_t", "accelerationStructureCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pAccelerationStructures, accelerationStructureCount, settings, "const VkAccelerationStructureNV*", "pAccelerationStructures", "const VkAccelerationStructureNV", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureNV); + dump_separate_members(settings); + dump_VkQueryType(queryType, settings, "VkQueryType", "queryType", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkQueryPool(queryPool, settings, "VkQueryPool", "queryPool", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(firstQuery, settings, "uint32_t", "firstQuery", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCompileDeferredNV(ApiDumpInstance& dump_inst, VkDevice device, VkPipeline pipeline, uint32_t shader) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipeline(pipeline, settings, "VkPipeline", "pipeline", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(shader, settings, "uint32_t", "shader", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetMemoryHostPointerPropertiesEXT(ApiDumpInstance& dump_inst, VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkExternalMemoryHandleTypeFlagBits(handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(pHostPointer, settings, "const void*", "pHostPointer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pMemoryHostPointerProperties, settings, "VkMemoryHostPointerPropertiesEXT*", "pMemoryHostPointerProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryHostPointerPropertiesEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdWriteBufferMarkerAMD(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipelineStageFlagBits(pipelineStage, settings, "VkPipelineStageFlagBits", "pipelineStage", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(dstBuffer, settings, "VkBuffer", "dstBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(dstOffset, settings, "VkDeviceSize", "dstOffset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(marker, settings, "uint32_t", "marker", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdWriteBufferMarker2AMD(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipelineStageFlags2(stage, settings, "VkPipelineStageFlags2", "stage", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(dstBuffer, settings, "VkBuffer", "dstBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(dstOffset, settings, "VkDeviceSize", "dstOffset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(marker, settings, "uint32_t", "marker", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainKHR* pTimeDomains) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pTimeDomainCount, settings, "uint32_t*", "pTimeDomainCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pTimeDomains, *pTimeDomainCount, settings, "VkTimeDomainKHR*", "pTimeDomains", "VkTimeDomainKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkTimeDomainKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetCalibratedTimestampsEXT(ApiDumpInstance& dump_inst, VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(timestampCount, settings, "uint32_t", "timestampCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pTimestampInfos, timestampCount, settings, "const VkCalibratedTimestampInfoKHR*", "pTimestampInfos", "const VkCalibratedTimestampInfoKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCalibratedTimestampInfoKHR); + dump_separate_members(settings); + dump_pointer_array(pTimestamps, timestampCount, settings, "uint64_t*", "pTimestamps", "uint64_t", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer(pMaxDeviation, settings, "uint64_t*", "pMaxDeviation", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdDrawMeshTasksNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(taskCount, settings, "uint32_t", "taskCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(firstTask, settings, "uint32_t", "firstTask", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdDrawMeshTasksIndirectNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(buffer, settings, "VkBuffer", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(offset, settings, "VkDeviceSize", "offset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(drawCount, settings, "uint32_t", "drawCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(stride, settings, "uint32_t", "stride", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdDrawMeshTasksIndirectCountNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(buffer, settings, "VkBuffer", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(offset, settings, "VkDeviceSize", "offset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(countBuffer, settings, "VkBuffer", "countBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(countBufferOffset, settings, "VkDeviceSize", "countBufferOffset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(maxDrawCount, settings, "uint32_t", "maxDrawCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(stride, settings, "uint32_t", "stride", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetExclusiveScissorEnableNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkBool32* pExclusiveScissorEnables) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(firstExclusiveScissor, settings, "uint32_t", "firstExclusiveScissor", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(exclusiveScissorCount, settings, "uint32_t", "exclusiveScissorCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pExclusiveScissorEnables, exclusiveScissorCount, settings, "const VkBool32*", "pExclusiveScissorEnables", "const VkBool32", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetExclusiveScissorNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(firstExclusiveScissor, settings, "uint32_t", "firstExclusiveScissor", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(exclusiveScissorCount, settings, "uint32_t", "exclusiveScissorCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pExclusiveScissors, exclusiveScissorCount, settings, "const VkRect2D*", "pExclusiveScissors", "const VkRect2D", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRect2D); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetCheckpointNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const void* pCheckpointMarker) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(pCheckpointMarker, settings, "const void*", "pCheckpointMarker", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetQueueCheckpointDataNV(ApiDumpInstance& dump_inst, VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkQueue(queue, settings, "VkQueue", "queue", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCheckpointDataCount, settings, "uint32_t*", "pCheckpointDataCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pCheckpointData, *pCheckpointDataCount, settings, "VkCheckpointDataNV*", "pCheckpointData", "VkCheckpointDataNV", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCheckpointDataNV); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetQueueCheckpointData2NV(ApiDumpInstance& dump_inst, VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkQueue(queue, settings, "VkQueue", "queue", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCheckpointDataCount, settings, "uint32_t*", "pCheckpointDataCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pCheckpointData, *pCheckpointDataCount, settings, "VkCheckpointData2NV*", "pCheckpointData", "VkCheckpointData2NV", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCheckpointData2NV); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkSetSwapchainPresentTimingQueueSizeEXT(ApiDumpInstance& dump_inst, VkDevice device, VkSwapchainKHR swapchain, uint32_t size) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkSwapchainKHR(swapchain, settings, "VkSwapchainKHR", "swapchain", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(size, settings, "uint32_t", "size", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetSwapchainTimingPropertiesEXT(ApiDumpInstance& dump_inst, VkDevice device, VkSwapchainKHR swapchain, VkSwapchainTimingPropertiesEXT* pSwapchainTimingProperties, uint64_t* pSwapchainTimingPropertiesCounter) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkSwapchainKHR(swapchain, settings, "VkSwapchainKHR", "swapchain", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pSwapchainTimingProperties, settings, "VkSwapchainTimingPropertiesEXT*", "pSwapchainTimingProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSwapchainTimingPropertiesEXT); + dump_separate_members(settings); + dump_pointer(pSwapchainTimingPropertiesCounter, settings, "uint64_t*", "pSwapchainTimingPropertiesCounter", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetSwapchainTimeDomainPropertiesEXT(ApiDumpInstance& dump_inst, VkDevice device, VkSwapchainKHR swapchain, VkSwapchainTimeDomainPropertiesEXT* pSwapchainTimeDomainProperties, uint64_t* pTimeDomainsCounter) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkSwapchainKHR(swapchain, settings, "VkSwapchainKHR", "swapchain", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pSwapchainTimeDomainProperties, settings, "VkSwapchainTimeDomainPropertiesEXT*", "pSwapchainTimeDomainProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSwapchainTimeDomainPropertiesEXT); + dump_separate_members(settings); + dump_pointer(pTimeDomainsCounter, settings, "uint64_t*", "pTimeDomainsCounter", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPastPresentationTimingEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkPastPresentationTimingInfoEXT* pPastPresentationTimingInfo, VkPastPresentationTimingPropertiesEXT* pPastPresentationTimingProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pPastPresentationTimingInfo, settings, "const VkPastPresentationTimingInfoEXT*", "pPastPresentationTimingInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPastPresentationTimingInfoEXT); + dump_separate_members(settings); + dump_pointer(pPastPresentationTimingProperties, settings, "VkPastPresentationTimingPropertiesEXT*", "pPastPresentationTimingProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPastPresentationTimingPropertiesEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkInitializePerformanceApiINTEL(ApiDumpInstance& dump_inst, VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInitializeInfo, settings, "const VkInitializePerformanceApiInfoINTEL*", "pInitializeInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkInitializePerformanceApiInfoINTEL); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkUninitializePerformanceApiINTEL(ApiDumpInstance& dump_inst, VkDevice device) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetPerformanceMarkerINTEL(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pMarkerInfo, settings, "const VkPerformanceMarkerInfoINTEL*", "pMarkerInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPerformanceMarkerInfoINTEL); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetPerformanceStreamMarkerINTEL(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pMarkerInfo, settings, "const VkPerformanceStreamMarkerInfoINTEL*", "pMarkerInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPerformanceStreamMarkerInfoINTEL); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetPerformanceOverrideINTEL(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pOverrideInfo, settings, "const VkPerformanceOverrideInfoINTEL*", "pOverrideInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPerformanceOverrideInfoINTEL); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkAcquirePerformanceConfigurationINTEL(ApiDumpInstance& dump_inst, VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAcquireInfo, settings, "const VkPerformanceConfigurationAcquireInfoINTEL*", "pAcquireInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPerformanceConfigurationAcquireInfoINTEL); + dump_separate_members(settings); + dump_pointer(pConfiguration, settings, "VkPerformanceConfigurationINTEL*", "pConfiguration", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPerformanceConfigurationINTEL); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkReleasePerformanceConfigurationINTEL(ApiDumpInstance& dump_inst, VkDevice device, VkPerformanceConfigurationINTEL configuration) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPerformanceConfigurationINTEL(configuration, settings, "VkPerformanceConfigurationINTEL", "configuration", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkQueueSetPerformanceConfigurationINTEL(ApiDumpInstance& dump_inst, VkQueue queue, VkPerformanceConfigurationINTEL configuration) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkQueue(queue, settings, "VkQueue", "queue", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPerformanceConfigurationINTEL(configuration, settings, "VkPerformanceConfigurationINTEL", "configuration", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPerformanceParameterINTEL(ApiDumpInstance& dump_inst, VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPerformanceParameterTypeINTEL(parameter, settings, "VkPerformanceParameterTypeINTEL", "parameter", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pValue, settings, "VkPerformanceValueINTEL*", "pValue", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPerformanceValueINTEL); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkSetLocalDimmingAMD(ApiDumpInstance& dump_inst, VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkSwapchainKHR(swapChain, settings, "VkSwapchainKHR", "swapChain", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(localDimmingEnable, settings, "VkBool32", "localDimmingEnable", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} +#if defined(VK_USE_PLATFORM_FUCHSIA) + +template +void dump_params_vkCreateImagePipeSurfaceFUCHSIA(ApiDumpInstance& dump_inst, VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkInstance(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkImagePipeSurfaceCreateInfoFUCHSIA*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImagePipeSurfaceCreateInfoFUCHSIA); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pSurface, settings, "VkSurfaceKHR*", "pSurface", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} +#endif // VK_USE_PLATFORM_FUCHSIA +#if defined(VK_USE_PLATFORM_METAL_EXT) + +template +void dump_params_vkCreateMetalSurfaceEXT(ApiDumpInstance& dump_inst, VkInstance instance, const VkMetalSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkInstance(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkMetalSurfaceCreateInfoEXT*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMetalSurfaceCreateInfoEXT); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pSurface, settings, "VkSurfaceKHR*", "pSurface", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} +#endif // VK_USE_PLATFORM_METAL_EXT + +template +void dump_params_vkGetBufferDeviceAddressEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkBufferDeviceAddressInfo* pInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkBufferDeviceAddressInfo*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferDeviceAddressInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceToolPropertiesEXT(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pToolCount, settings, "uint32_t*", "pToolCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pToolProperties, *pToolCount, settings, "VkPhysicalDeviceToolProperties*", "pToolProperties", "VkPhysicalDeviceToolProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceToolProperties); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pPropertyCount, settings, "uint32_t*", "pPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pProperties, *pPropertyCount, settings, "VkCooperativeMatrixPropertiesNV*", "pProperties", "VkCooperativeMatrixPropertiesNV", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCooperativeMatrixPropertiesNV); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCombinationCount, settings, "uint32_t*", "pCombinationCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pCombinations, *pCombinationCount, settings, "VkFramebufferMixedSamplesCombinationNV*", "pCombinations", "VkFramebufferMixedSamplesCombinationNV", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkFramebufferMixedSamplesCombinationNV); + dump_post_params_formatting(settings); + flush(settings); + } +} +#if defined(VK_USE_PLATFORM_WIN32_KHR) + +template +void dump_params_vkGetPhysicalDeviceSurfacePresentModes2EXT(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pSurfaceInfo, settings, "const VkPhysicalDeviceSurfaceInfo2KHR*", "pSurfaceInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceSurfaceInfo2KHR); + dump_separate_members(settings); + dump_pointer(pPresentModeCount, settings, "uint32_t*", "pPresentModeCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pPresentModes, *pPresentModeCount, settings, "VkPresentModeKHR*", "pPresentModes", "VkPresentModeKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPresentModeKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkAcquireFullScreenExclusiveModeEXT(ApiDumpInstance& dump_inst, VkDevice device, VkSwapchainKHR swapchain) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkSwapchainKHR(swapchain, settings, "VkSwapchainKHR", "swapchain", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkReleaseFullScreenExclusiveModeEXT(ApiDumpInstance& dump_inst, VkDevice device, VkSwapchainKHR swapchain) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkSwapchainKHR(swapchain, settings, "VkSwapchainKHR", "swapchain", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetDeviceGroupSurfacePresentModes2EXT(ApiDumpInstance& dump_inst, VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pSurfaceInfo, settings, "const VkPhysicalDeviceSurfaceInfo2KHR*", "pSurfaceInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceSurfaceInfo2KHR); + dump_separate_members(settings); + dump_pointer(pModes, settings, "VkDeviceGroupPresentModeFlagsKHR*", "pModes", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceGroupPresentModeFlagsKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} +#endif // VK_USE_PLATFORM_WIN32_KHR + +template +void dump_params_vkCreateHeadlessSurfaceEXT(ApiDumpInstance& dump_inst, VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkInstance(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkHeadlessSurfaceCreateInfoEXT*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkHeadlessSurfaceCreateInfoEXT); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pSurface, settings, "VkSurfaceKHR*", "pSurface", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetLineStippleEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(lineStippleFactor, settings, "uint32_t", "lineStippleFactor", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(lineStipplePattern, settings, "uint16_t", "lineStipplePattern", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkResetQueryPoolEXT(ApiDumpInstance& dump_inst, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkQueryPool(queryPool, settings, "VkQueryPool", "queryPool", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(firstQuery, settings, "uint32_t", "firstQuery", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(queryCount, settings, "uint32_t", "queryCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetCullModeEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkCullModeFlags(cullMode, settings, "VkCullModeFlags", "cullMode", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetFrontFaceEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkFrontFace frontFace) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkFrontFace(frontFace, settings, "VkFrontFace", "frontFace", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetPrimitiveTopologyEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPrimitiveTopology(primitiveTopology, settings, "VkPrimitiveTopology", "primitiveTopology", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetViewportWithCountEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(viewportCount, settings, "uint32_t", "viewportCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pViewports, viewportCount, settings, "const VkViewport*", "pViewports", "const VkViewport", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkViewport); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetScissorWithCountEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(scissorCount, settings, "uint32_t", "scissorCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pScissors, scissorCount, settings, "const VkRect2D*", "pScissors", "const VkRect2D", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRect2D); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdBindVertexBuffers2EXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(firstBinding, settings, "uint32_t", "firstBinding", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(bindingCount, settings, "uint32_t", "bindingCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pBuffers, bindingCount, settings, "const VkBuffer*", "pBuffers", "const VkBuffer", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBuffer); + dump_separate_members(settings); + dump_pointer_array(pOffsets, bindingCount, settings, "const VkDeviceSize*", "pOffsets", "const VkDeviceSize", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pSizes, bindingCount, settings, "const VkDeviceSize*", "pSizes", "const VkDeviceSize", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pStrides, bindingCount, settings, "const VkDeviceSize*", "pStrides", "const VkDeviceSize", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetDepthTestEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(depthTestEnable, settings, "VkBool32", "depthTestEnable", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetDepthWriteEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(depthWriteEnable, settings, "VkBool32", "depthWriteEnable", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetDepthCompareOpEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkCompareOp(depthCompareOp, settings, "VkCompareOp", "depthCompareOp", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetDepthBoundsTestEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(depthBoundsTestEnable, settings, "VkBool32", "depthBoundsTestEnable", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetStencilTestEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(stencilTestEnable, settings, "VkBool32", "stencilTestEnable", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetStencilOpEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkStencilFaceFlags(faceMask, settings, "VkStencilFaceFlags", "faceMask", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkStencilOp(failOp, settings, "VkStencilOp", "failOp", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkStencilOp(passOp, settings, "VkStencilOp", "passOp", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkStencilOp(depthFailOp, settings, "VkStencilOp", "depthFailOp", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkCompareOp(compareOp, settings, "VkCompareOp", "compareOp", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCopyMemoryToImageEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCopyMemoryToImageInfo, settings, "const VkCopyMemoryToImageInfo*", "pCopyMemoryToImageInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyMemoryToImageInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCopyImageToMemoryEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCopyImageToMemoryInfo, settings, "const VkCopyImageToMemoryInfo*", "pCopyImageToMemoryInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyImageToMemoryInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCopyImageToImageEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkCopyImageToImageInfo* pCopyImageToImageInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCopyImageToImageInfo, settings, "const VkCopyImageToImageInfo*", "pCopyImageToImageInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyImageToImageInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkTransitionImageLayoutEXT(ApiDumpInstance& dump_inst, VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfo* pTransitions) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(transitionCount, settings, "uint32_t", "transitionCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pTransitions, transitionCount, settings, "const VkHostImageLayoutTransitionInfo*", "pTransitions", "const VkHostImageLayoutTransitionInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkHostImageLayoutTransitionInfo); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetImageSubresourceLayout2EXT(ApiDumpInstance& dump_inst, VkDevice device, VkImage image, const VkImageSubresource2* pSubresource, VkSubresourceLayout2* pLayout) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImage(image, settings, "VkImage", "image", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pSubresource, settings, "const VkImageSubresource2*", "pSubresource", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageSubresource2); + dump_separate_members(settings); + dump_pointer(pLayout, settings, "VkSubresourceLayout2*", "pLayout", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSubresourceLayout2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkReleaseSwapchainImagesEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkReleaseSwapchainImagesInfoKHR* pReleaseInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pReleaseInfo, settings, "const VkReleaseSwapchainImagesInfoKHR*", "pReleaseInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkReleaseSwapchainImagesInfoKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetGeneratedCommandsMemoryRequirementsNV(ApiDumpInstance& dump_inst, VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkGeneratedCommandsMemoryRequirementsInfoNV*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkGeneratedCommandsMemoryRequirementsInfoNV); + dump_separate_members(settings); + dump_pointer(pMemoryRequirements, settings, "VkMemoryRequirements2*", "pMemoryRequirements", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdPreprocessGeneratedCommandsNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pGeneratedCommandsInfo, settings, "const VkGeneratedCommandsInfoNV*", "pGeneratedCommandsInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkGeneratedCommandsInfoNV); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdExecuteGeneratedCommandsNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(isPreprocessed, settings, "VkBool32", "isPreprocessed", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pGeneratedCommandsInfo, settings, "const VkGeneratedCommandsInfoNV*", "pGeneratedCommandsInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkGeneratedCommandsInfoNV); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdBindPipelineShaderGroupNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipelineBindPoint(pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipeline(pipeline, settings, "VkPipeline", "pipeline", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(groupIndex, settings, "uint32_t", "groupIndex", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateIndirectCommandsLayoutNV(ApiDumpInstance& dump_inst, VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNV* pIndirectCommandsLayout) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkIndirectCommandsLayoutCreateInfoNV*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkIndirectCommandsLayoutCreateInfoNV); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pIndirectCommandsLayout, settings, "VkIndirectCommandsLayoutNV*", "pIndirectCommandsLayout", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkIndirectCommandsLayoutNV); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyIndirectCommandsLayoutNV(ApiDumpInstance& dump_inst, VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkIndirectCommandsLayoutNV(indirectCommandsLayout, settings, "VkIndirectCommandsLayoutNV", "indirectCommandsLayout", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetDepthBias2EXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkDepthBiasInfoEXT* pDepthBiasInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pDepthBiasInfo, settings, "const VkDepthBiasInfoEXT*", "pDepthBiasInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDepthBiasInfoEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkAcquireDrmDisplayEXT(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(drmFd, settings, "int32_t", "drmFd", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDisplayKHR(display, settings, "VkDisplayKHR", "display", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetDrmDisplayEXT(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR* display) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(drmFd, settings, "int32_t", "drmFd", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(connectorId, settings, "uint32_t", "connectorId", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(display, settings, "VkDisplayKHR*", "display", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreatePrivateDataSlotEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkPrivateDataSlotCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPrivateDataSlotCreateInfo); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pPrivateDataSlot, settings, "VkPrivateDataSlot*", "pPrivateDataSlot", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPrivateDataSlot); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyPrivateDataSlotEXT(ApiDumpInstance& dump_inst, VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPrivateDataSlot(privateDataSlot, settings, "VkPrivateDataSlot", "privateDataSlot", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkSetPrivateDataEXT(ApiDumpInstance& dump_inst, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkObjectType(objectType, settings, "VkObjectType", "objectType", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_uint64_t_as_pointer(objectHandle, settings, "uint64_t", "objectHandle", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPrivateDataSlot(privateDataSlot, settings, "VkPrivateDataSlot", "privateDataSlot", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(data, settings, "uint64_t", "data", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPrivateDataEXT(ApiDumpInstance& dump_inst, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkObjectType(objectType, settings, "VkObjectType", "objectType", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_uint64_t_as_pointer(objectHandle, settings, "uint64_t", "objectHandle", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPrivateDataSlot(privateDataSlot, settings, "VkPrivateDataSlot", "privateDataSlot", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pData, settings, "uint64_t*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} +#if defined(VK_ENABLE_BETA_EXTENSIONS) + +template +void dump_params_vkCreateCudaModuleNV(ApiDumpInstance& dump_inst, VkDevice device, const VkCudaModuleCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCudaModuleNV* pModule) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkCudaModuleCreateInfoNV*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCudaModuleCreateInfoNV); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pModule, settings, "VkCudaModuleNV*", "pModule", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCudaModuleNV); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetCudaModuleCacheNV(ApiDumpInstance& dump_inst, VkDevice device, VkCudaModuleNV module, size_t* pCacheSize, void* pCacheData) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkCudaModuleNV(module, settings, "VkCudaModuleNV", "module", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCacheSize, settings, "size_t*", "pCacheSize", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_type(pCacheData, settings, "void*", "pCacheData", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateCudaFunctionNV(ApiDumpInstance& dump_inst, VkDevice device, const VkCudaFunctionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCudaFunctionNV* pFunction) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkCudaFunctionCreateInfoNV*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCudaFunctionCreateInfoNV); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pFunction, settings, "VkCudaFunctionNV*", "pFunction", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCudaFunctionNV); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyCudaModuleNV(ApiDumpInstance& dump_inst, VkDevice device, VkCudaModuleNV module, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkCudaModuleNV(module, settings, "VkCudaModuleNV", "module", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyCudaFunctionNV(ApiDumpInstance& dump_inst, VkDevice device, VkCudaFunctionNV function, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkCudaFunctionNV(function, settings, "VkCudaFunctionNV", "function", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdCudaLaunchKernelNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCudaLaunchInfoNV* pLaunchInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pLaunchInfo, settings, "const VkCudaLaunchInfoNV*", "pLaunchInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCudaLaunchInfoNV); + dump_post_params_formatting(settings); + flush(settings); + } +} +#endif // VK_ENABLE_BETA_EXTENSIONS + +template +void dump_params_vkCmdDispatchTileQCOM(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkDispatchTileInfoQCOM* pDispatchTileInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pDispatchTileInfo, settings, "const VkDispatchTileInfoQCOM*", "pDispatchTileInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDispatchTileInfoQCOM); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdBeginPerTileExecutionQCOM(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkPerTileBeginInfoQCOM* pPerTileBeginInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pPerTileBeginInfo, settings, "const VkPerTileBeginInfoQCOM*", "pPerTileBeginInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPerTileBeginInfoQCOM); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdEndPerTileExecutionQCOM(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkPerTileEndInfoQCOM* pPerTileEndInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pPerTileEndInfo, settings, "const VkPerTileEndInfoQCOM*", "pPerTileEndInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPerTileEndInfoQCOM); + dump_post_params_formatting(settings); + flush(settings); + } +} +#if defined(VK_USE_PLATFORM_METAL_EXT) + +template +void dump_params_vkExportMetalObjectsEXT(ApiDumpInstance& dump_inst, VkDevice device, VkExportMetalObjectsInfoEXT* pMetalObjectsInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pMetalObjectsInfo, settings, "VkExportMetalObjectsInfoEXT*", "pMetalObjectsInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkExportMetalObjectsInfoEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} +#endif // VK_USE_PLATFORM_METAL_EXT + +template +void dump_params_vkGetDescriptorSetLayoutSizeEXT(ApiDumpInstance& dump_inst, VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize* pLayoutSizeInBytes) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDescriptorSetLayout(layout, settings, "VkDescriptorSetLayout", "layout", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pLayoutSizeInBytes, settings, "VkDeviceSize*", "pLayoutSizeInBytes", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetDescriptorSetLayoutBindingOffsetEXT(ApiDumpInstance& dump_inst, VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize* pOffset) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDescriptorSetLayout(layout, settings, "VkDescriptorSetLayout", "layout", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(binding, settings, "uint32_t", "binding", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pOffset, settings, "VkDeviceSize*", "pOffset", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetDescriptorEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkDescriptorGetInfoEXT* pDescriptorInfo, size_t dataSize, void* pDescriptor) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pDescriptorInfo, settings, "const VkDescriptorGetInfoEXT*", "pDescriptorInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorGetInfoEXT); + dump_separate_members(settings); + dump_type(dataSize, settings, "size_t", "dataSize", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(pDescriptor, settings, "void*", "pDescriptor", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdBindDescriptorBuffersEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT* pBindingInfos) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(bufferCount, settings, "uint32_t", "bufferCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pBindingInfos, bufferCount, settings, "const VkDescriptorBufferBindingInfoEXT*", "pBindingInfos", "const VkDescriptorBufferBindingInfoEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorBufferBindingInfoEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetDescriptorBufferOffsetsEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t* pBufferIndices, const VkDeviceSize* pOffsets) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipelineBindPoint(pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipelineLayout(layout, settings, "VkPipelineLayout", "layout", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(firstSet, settings, "uint32_t", "firstSet", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(setCount, settings, "uint32_t", "setCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pBufferIndices, setCount, settings, "const uint32_t*", "pBufferIndices", "const uint32_t", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pOffsets, setCount, settings, "const VkDeviceSize*", "pOffsets", "const VkDeviceSize", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdBindDescriptorBufferEmbeddedSamplersEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipelineBindPoint(pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipelineLayout(layout, settings, "VkPipelineLayout", "layout", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(set, settings, "uint32_t", "set", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetBufferOpaqueCaptureDescriptorDataEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT* pInfo, void* pData) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkBufferCaptureDescriptorDataInfoEXT*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferCaptureDescriptorDataInfoEXT); + dump_separate_members(settings); + dump_type(pData, settings, "void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetImageOpaqueCaptureDescriptorDataEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkImageCaptureDescriptorDataInfoEXT* pInfo, void* pData) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkImageCaptureDescriptorDataInfoEXT*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageCaptureDescriptorDataInfoEXT); + dump_separate_members(settings); + dump_type(pData, settings, "void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetImageViewOpaqueCaptureDescriptorDataEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, void* pData) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkImageViewCaptureDescriptorDataInfoEXT*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageViewCaptureDescriptorDataInfoEXT); + dump_separate_members(settings); + dump_type(pData, settings, "void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetSamplerOpaqueCaptureDescriptorDataEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT* pInfo, void* pData) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkSamplerCaptureDescriptorDataInfoEXT*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSamplerCaptureDescriptorDataInfoEXT); + dump_separate_members(settings); + dump_type(pData, settings, "void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, void* pData) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkAccelerationStructureCaptureDescriptorDataInfoEXT*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureCaptureDescriptorDataInfoEXT); + dump_separate_members(settings); + dump_type(pData, settings, "void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetFragmentShadingRateEnumNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkFragmentShadingRateNV(shadingRate, settings, "VkFragmentShadingRateNV", "shadingRate", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(combinerOps, 2, settings, "const VkFragmentShadingRateCombinerOpKHR[2]", "combinerOps", "const VkFragmentShadingRateCombinerOpKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkFragmentShadingRateCombinerOpKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetDeviceFaultInfoEXT(ApiDumpInstance& dump_inst, VkDevice device, VkDeviceFaultCountsEXT* pFaultCounts, VkDeviceFaultInfoEXT* pFaultInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pFaultCounts, settings, "VkDeviceFaultCountsEXT*", "pFaultCounts", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceFaultCountsEXT); + dump_separate_members(settings); + dump_pointer(pFaultInfo, settings, "VkDeviceFaultInfoEXT*", "pFaultInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceFaultInfoEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} +#if defined(VK_USE_PLATFORM_WIN32_KHR) + +template +void dump_params_vkAcquireWinrtDisplayNV(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, VkDisplayKHR display) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDisplayKHR(display, settings, "VkDisplayKHR", "display", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetWinrtDisplayNV(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR* pDisplay) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(deviceRelativeId, settings, "uint32_t", "deviceRelativeId", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pDisplay, settings, "VkDisplayKHR*", "pDisplay", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDisplayKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} +#endif // VK_USE_PLATFORM_WIN32_KHR +#if defined(VK_USE_PLATFORM_DIRECTFB_EXT) + +template +void dump_params_vkCreateDirectFBSurfaceEXT(ApiDumpInstance& dump_inst, VkInstance instance, const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkInstance(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkDirectFBSurfaceCreateInfoEXT*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDirectFBSurfaceCreateInfoEXT); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pSurface, settings, "VkSurfaceKHR*", "pSurface", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceDirectFBPresentationSupportEXT(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, IDirectFB* dfb) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(dfb, settings, "IDirectFB*", "dfb", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} +#endif // VK_USE_PLATFORM_DIRECTFB_EXT + +template +void dump_params_vkCmdSetVertexInputEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(vertexBindingDescriptionCount, settings, "uint32_t", "vertexBindingDescriptionCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pVertexBindingDescriptions, vertexBindingDescriptionCount, settings, "const VkVertexInputBindingDescription2EXT*", "pVertexBindingDescriptions", "const VkVertexInputBindingDescription2EXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkVertexInputBindingDescription2EXT); + dump_separate_members(settings); + dump_type(vertexAttributeDescriptionCount, settings, "uint32_t", "vertexAttributeDescriptionCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pVertexAttributeDescriptions, vertexAttributeDescriptionCount, settings, "const VkVertexInputAttributeDescription2EXT*", "pVertexAttributeDescriptions", "const VkVertexInputAttributeDescription2EXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkVertexInputAttributeDescription2EXT); + dump_post_params_formatting(settings); + flush(settings); + } +} +#if defined(VK_USE_PLATFORM_FUCHSIA) + +template +void dump_params_vkGetMemoryZirconHandleFUCHSIA(ApiDumpInstance& dump_inst, VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pGetZirconHandleInfo, settings, "const VkMemoryGetZirconHandleInfoFUCHSIA*", "pGetZirconHandleInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryGetZirconHandleInfoFUCHSIA); + dump_separate_members(settings); + dump_pointer(pZirconHandle, settings, "zx_handle_t*", "pZirconHandle", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetMemoryZirconHandlePropertiesFUCHSIA(ApiDumpInstance& dump_inst, VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkExternalMemoryHandleTypeFlagBits(handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(zirconHandle, settings, "zx_handle_t", "zirconHandle", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pMemoryZirconHandleProperties, settings, "VkMemoryZirconHandlePropertiesFUCHSIA*", "pMemoryZirconHandleProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryZirconHandlePropertiesFUCHSIA); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkImportSemaphoreZirconHandleFUCHSIA(ApiDumpInstance& dump_inst, VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pImportSemaphoreZirconHandleInfo, settings, "const VkImportSemaphoreZirconHandleInfoFUCHSIA*", "pImportSemaphoreZirconHandleInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImportSemaphoreZirconHandleInfoFUCHSIA); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetSemaphoreZirconHandleFUCHSIA(ApiDumpInstance& dump_inst, VkDevice device, const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pGetZirconHandleInfo, settings, "const VkSemaphoreGetZirconHandleInfoFUCHSIA*", "pGetZirconHandleInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSemaphoreGetZirconHandleInfoFUCHSIA); + dump_separate_members(settings); + dump_pointer(pZirconHandle, settings, "zx_handle_t*", "pZirconHandle", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateBufferCollectionFUCHSIA(ApiDumpInstance& dump_inst, VkDevice device, const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferCollectionFUCHSIA* pCollection) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkBufferCollectionCreateInfoFUCHSIA*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferCollectionCreateInfoFUCHSIA); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pCollection, settings, "VkBufferCollectionFUCHSIA*", "pCollection", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferCollectionFUCHSIA); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkSetBufferCollectionImageConstraintsFUCHSIA(ApiDumpInstance& dump_inst, VkDevice device, VkBufferCollectionFUCHSIA collection, const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBufferCollectionFUCHSIA(collection, settings, "VkBufferCollectionFUCHSIA", "collection", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pImageConstraintsInfo, settings, "const VkImageConstraintsInfoFUCHSIA*", "pImageConstraintsInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageConstraintsInfoFUCHSIA); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkSetBufferCollectionBufferConstraintsFUCHSIA(ApiDumpInstance& dump_inst, VkDevice device, VkBufferCollectionFUCHSIA collection, const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBufferCollectionFUCHSIA(collection, settings, "VkBufferCollectionFUCHSIA", "collection", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pBufferConstraintsInfo, settings, "const VkBufferConstraintsInfoFUCHSIA*", "pBufferConstraintsInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferConstraintsInfoFUCHSIA); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyBufferCollectionFUCHSIA(ApiDumpInstance& dump_inst, VkDevice device, VkBufferCollectionFUCHSIA collection, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBufferCollectionFUCHSIA(collection, settings, "VkBufferCollectionFUCHSIA", "collection", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetBufferCollectionPropertiesFUCHSIA(ApiDumpInstance& dump_inst, VkDevice device, VkBufferCollectionFUCHSIA collection, VkBufferCollectionPropertiesFUCHSIA* pProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBufferCollectionFUCHSIA(collection, settings, "VkBufferCollectionFUCHSIA", "collection", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pProperties, settings, "VkBufferCollectionPropertiesFUCHSIA*", "pProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBufferCollectionPropertiesFUCHSIA); + dump_post_params_formatting(settings); + flush(settings); + } +} +#endif // VK_USE_PLATFORM_FUCHSIA + +template +void dump_params_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(ApiDumpInstance& dump_inst, VkDevice device, VkRenderPass renderpass, VkExtent2D* pMaxWorkgroupSize) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkRenderPass(renderpass, settings, "VkRenderPass", "renderpass", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pMaxWorkgroupSize, 1, settings, "VkExtent2D*", "pMaxWorkgroupSize", "VkExtent2D", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkExtent2D); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSubpassShadingHUAWEI(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdBindInvocationMaskHUAWEI(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImageView(imageView, settings, "VkImageView", "imageView", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(imageLayout, settings, "VkImageLayout", "imageLayout", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetMemoryRemoteAddressNV(ApiDumpInstance& dump_inst, VkDevice device, const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, VkRemoteAddressNV* pAddress) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pMemoryGetRemoteAddressInfo, settings, "const VkMemoryGetRemoteAddressInfoNV*", "pMemoryGetRemoteAddressInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryGetRemoteAddressInfoNV); + dump_separate_members(settings); + dump_type(pAddress, settings, "VkRemoteAddressNV*", "pAddress", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPipelinePropertiesEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkPipelineInfoEXT* pPipelineInfo, VkBaseOutStructure* pPipelineProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pPipelineInfo, settings, "const VkPipelineInfoEXT*", "pPipelineInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineInfoKHR); + dump_separate_members(settings); + dump_pointer(pPipelineProperties, settings, "VkBaseOutStructure*", "pPipelineProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBaseOutStructure); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetPatchControlPointsEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t patchControlPoints) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(patchControlPoints, settings, "uint32_t", "patchControlPoints", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetRasterizerDiscardEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(rasterizerDiscardEnable, settings, "VkBool32", "rasterizerDiscardEnable", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetDepthBiasEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(depthBiasEnable, settings, "VkBool32", "depthBiasEnable", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetLogicOpEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkLogicOp logicOp) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkLogicOp(logicOp, settings, "VkLogicOp", "logicOp", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetPrimitiveRestartEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(primitiveRestartEnable, settings, "VkBool32", "primitiveRestartEnable", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} +#if defined(VK_USE_PLATFORM_SCREEN_QNX) + +template +void dump_params_vkCreateScreenSurfaceQNX(ApiDumpInstance& dump_inst, VkInstance instance, const VkScreenSurfaceCreateInfoQNX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkInstance(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkScreenSurfaceCreateInfoQNX*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkScreenSurfaceCreateInfoQNX); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pSurface, settings, "VkSurfaceKHR*", "pSurface", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceScreenPresentationSupportQNX(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct _screen_window* window) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(window, settings, "struct _screen_window*", "window", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} +#endif // VK_USE_PLATFORM_SCREEN_QNX + +template +void dump_params_vkCmdSetColorWriteEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(attachmentCount, settings, "uint32_t", "attachmentCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pColorWriteEnables, attachmentCount, settings, "const VkBool32*", "pColorWriteEnables", "const VkBool32", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdDrawMultiEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(drawCount, settings, "uint32_t", "drawCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pVertexInfo, drawCount, settings, "const VkMultiDrawInfoEXT*", "pVertexInfo", "const VkMultiDrawInfoEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMultiDrawInfoEXT); + dump_separate_members(settings); + dump_type(instanceCount, settings, "uint32_t", "instanceCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(firstInstance, settings, "uint32_t", "firstInstance", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(stride, settings, "uint32_t", "stride", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdDrawMultiIndexedEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(drawCount, settings, "uint32_t", "drawCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pIndexInfo, drawCount, settings, "const VkMultiDrawIndexedInfoEXT*", "pIndexInfo", "const VkMultiDrawIndexedInfoEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMultiDrawIndexedInfoEXT); + dump_separate_members(settings); + dump_type(instanceCount, settings, "uint32_t", "instanceCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(firstInstance, settings, "uint32_t", "firstInstance", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(stride, settings, "uint32_t", "stride", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pVertexOffset, settings, "const int32_t*", "pVertexOffset", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateMicromapEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkMicromapCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkMicromapEXT* pMicromap) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkMicromapCreateInfoEXT*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMicromapCreateInfoEXT); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pMicromap, settings, "VkMicromapEXT*", "pMicromap", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMicromapEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyMicromapEXT(ApiDumpInstance& dump_inst, VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkMicromapEXT(micromap, settings, "VkMicromapEXT", "micromap", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdBuildMicromapsEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(infoCount, settings, "uint32_t", "infoCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pInfos, infoCount, settings, "const VkMicromapBuildInfoEXT*", "pInfos", "const VkMicromapBuildInfoEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMicromapBuildInfoEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkBuildMicromapsEXT(ApiDumpInstance& dump_inst, VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDeferredOperationKHR(deferredOperation, settings, "VkDeferredOperationKHR", "deferredOperation", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(infoCount, settings, "uint32_t", "infoCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pInfos, infoCount, settings, "const VkMicromapBuildInfoEXT*", "pInfos", "const VkMicromapBuildInfoEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMicromapBuildInfoEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCopyMicromapEXT(ApiDumpInstance& dump_inst, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT* pInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDeferredOperationKHR(deferredOperation, settings, "VkDeferredOperationKHR", "deferredOperation", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkCopyMicromapInfoEXT*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyMicromapInfoEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCopyMicromapToMemoryEXT(ApiDumpInstance& dump_inst, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT* pInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDeferredOperationKHR(deferredOperation, settings, "VkDeferredOperationKHR", "deferredOperation", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkCopyMicromapToMemoryInfoEXT*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyMicromapToMemoryInfoEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCopyMemoryToMicromapEXT(ApiDumpInstance& dump_inst, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT* pInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDeferredOperationKHR(deferredOperation, settings, "VkDeferredOperationKHR", "deferredOperation", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkCopyMemoryToMicromapInfoEXT*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyMemoryToMicromapInfoEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkWriteMicromapsPropertiesEXT(ApiDumpInstance& dump_inst, VkDevice device, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, size_t dataSize, void* pData, size_t stride) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(micromapCount, settings, "uint32_t", "micromapCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pMicromaps, micromapCount, settings, "const VkMicromapEXT*", "pMicromaps", "const VkMicromapEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMicromapEXT); + dump_separate_members(settings); + dump_VkQueryType(queryType, settings, "VkQueryType", "queryType", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(dataSize, settings, "size_t", "dataSize", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(pData, settings, "void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(stride, settings, "size_t", "stride", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdCopyMicromapEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT* pInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkCopyMicromapInfoEXT*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyMicromapInfoEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdCopyMicromapToMemoryEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT* pInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkCopyMicromapToMemoryInfoEXT*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyMicromapToMemoryInfoEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdCopyMemoryToMicromapEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT* pInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkCopyMemoryToMicromapInfoEXT*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyMemoryToMicromapInfoEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdWriteMicromapsPropertiesEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(micromapCount, settings, "uint32_t", "micromapCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pMicromaps, micromapCount, settings, "const VkMicromapEXT*", "pMicromaps", "const VkMicromapEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMicromapEXT); + dump_separate_members(settings); + dump_VkQueryType(queryType, settings, "VkQueryType", "queryType", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkQueryPool(queryPool, settings, "VkQueryPool", "queryPool", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(firstQuery, settings, "uint32_t", "firstQuery", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetDeviceMicromapCompatibilityEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkMicromapVersionInfoEXT* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pVersionInfo, settings, "const VkMicromapVersionInfoEXT*", "pVersionInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMicromapVersionInfoEXT); + dump_separate_members(settings); + dump_pointer(pCompatibility, settings, "VkAccelerationStructureCompatibilityKHR*", "pCompatibility", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureCompatibilityKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetMicromapBuildSizesEXT(ApiDumpInstance& dump_inst, VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT* pBuildInfo, VkMicromapBuildSizesInfoEXT* pSizeInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkAccelerationStructureBuildTypeKHR(buildType, settings, "VkAccelerationStructureBuildTypeKHR", "buildType", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pBuildInfo, settings, "const VkMicromapBuildInfoEXT*", "pBuildInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMicromapBuildInfoEXT); + dump_separate_members(settings); + dump_pointer(pSizeInfo, settings, "VkMicromapBuildSizesInfoEXT*", "pSizeInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMicromapBuildSizesInfoEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdDrawClusterHUAWEI(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(groupCountX, settings, "uint32_t", "groupCountX", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(groupCountY, settings, "uint32_t", "groupCountY", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(groupCountZ, settings, "uint32_t", "groupCountZ", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdDrawClusterIndirectHUAWEI(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(buffer, settings, "VkBuffer", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(offset, settings, "VkDeviceSize", "offset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkSetDeviceMemoryPriorityEXT(ApiDumpInstance& dump_inst, VkDevice device, VkDeviceMemory memory, float priority) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDeviceMemory(memory, settings, "VkDeviceMemory", "memory", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(priority, settings, "float", "priority", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetDescriptorSetLayoutHostMappingInfoVALVE(ApiDumpInstance& dump_inst, VkDevice device, const VkDescriptorSetBindingReferenceVALVE* pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pBindingReference, settings, "const VkDescriptorSetBindingReferenceVALVE*", "pBindingReference", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorSetBindingReferenceVALVE); + dump_separate_members(settings); + dump_pointer(pHostMapping, settings, "VkDescriptorSetLayoutHostMappingInfoVALVE*", "pHostMapping", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDescriptorSetLayoutHostMappingInfoVALVE); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetDescriptorSetHostMappingVALVE(ApiDumpInstance& dump_inst, VkDevice device, VkDescriptorSet descriptorSet, void** ppData) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDescriptorSet(descriptorSet, settings, "VkDescriptorSet", "descriptorSet", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(ppData, settings, "void**", "ppData", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdCopyMemoryIndirectNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type_hex(copyBufferAddress, settings, "VkDeviceAddress", "copyBufferAddress", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(copyCount, settings, "uint32_t", "copyCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(stride, settings, "uint32_t", "stride", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdCopyMemoryToImageIndirectNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VkImage dstImage, VkImageLayout dstImageLayout, const VkImageSubresourceLayers* pImageSubresources) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type_hex(copyBufferAddress, settings, "VkDeviceAddress", "copyBufferAddress", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(copyCount, settings, "uint32_t", "copyCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(stride, settings, "uint32_t", "stride", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImage(dstImage, settings, "VkImage", "dstImage", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(dstImageLayout, settings, "VkImageLayout", "dstImageLayout", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pImageSubresources, copyCount, settings, "const VkImageSubresourceLayers*", "pImageSubresources", "const VkImageSubresourceLayers", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkImageSubresourceLayers); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdDecompressMemoryNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t decompressRegionCount, const VkDecompressMemoryRegionNV* pDecompressMemoryRegions) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(decompressRegionCount, settings, "uint32_t", "decompressRegionCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pDecompressMemoryRegions, decompressRegionCount, settings, "const VkDecompressMemoryRegionNV*", "pDecompressMemoryRegions", "const VkDecompressMemoryRegionNV", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDecompressMemoryRegionNV); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdDecompressMemoryIndirectCountNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t stride) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type_hex(indirectCommandsAddress, settings, "VkDeviceAddress", "indirectCommandsAddress", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type_hex(indirectCommandsCountAddress, settings, "VkDeviceAddress", "indirectCommandsCountAddress", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(stride, settings, "uint32_t", "stride", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPipelineIndirectMemoryRequirementsNV(ApiDumpInstance& dump_inst, VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo, VkMemoryRequirements2* pMemoryRequirements) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkComputePipelineCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkComputePipelineCreateInfo); + dump_separate_members(settings); + dump_pointer(pMemoryRequirements, settings, "VkMemoryRequirements2*", "pMemoryRequirements", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdUpdatePipelineIndirectBufferNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipelineBindPoint(pipelineBindPoint, settings, "VkPipelineBindPoint", "pipelineBindPoint", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipeline(pipeline, settings, "VkPipeline", "pipeline", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPipelineIndirectDeviceAddressNV(ApiDumpInstance& dump_inst, VkDevice device, const VkPipelineIndirectDeviceAddressInfoNV* pInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkPipelineIndirectDeviceAddressInfoNV*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipelineIndirectDeviceAddressInfoNV); + dump_post_params_formatting(settings); + flush(settings); + } +} +#if defined(VK_USE_PLATFORM_OHOS) + +template +void dump_params_vkGetNativeBufferPropertiesOHOS(ApiDumpInstance& dump_inst, VkDevice device, const struct OH_NativeBuffer* buffer, VkNativeBufferPropertiesOHOS* pProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(buffer, settings, "const struct OH_NativeBuffer*", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pProperties, settings, "VkNativeBufferPropertiesOHOS*", "pProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkNativeBufferPropertiesOHOS); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetMemoryNativeBufferOHOS(ApiDumpInstance& dump_inst, VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, struct OH_NativeBuffer** pBuffer) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkMemoryGetNativeBufferInfoOHOS*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryGetNativeBufferInfoOHOS); + dump_separate_members(settings); + dump_type(pBuffer, settings, "struct OH_NativeBuffer**", "pBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} +#endif // VK_USE_PLATFORM_OHOS + +template +void dump_params_vkCmdSetDepthClampEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 depthClampEnable) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(depthClampEnable, settings, "VkBool32", "depthClampEnable", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetPolygonModeEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkPolygonMode polygonMode) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPolygonMode(polygonMode, settings, "VkPolygonMode", "polygonMode", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetRasterizationSamplesEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkSampleCountFlagBits(rasterizationSamples, settings, "VkSampleCountFlagBits", "rasterizationSamples", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetSampleMaskEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask* pSampleMask) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkSampleCountFlagBits(samples, settings, "VkSampleCountFlagBits", "samples", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pSampleMask, (samples + 31) / 32, settings, "const VkSampleMask*", "pSampleMask", "const VkSampleMask", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetAlphaToCoverageEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(alphaToCoverageEnable, settings, "VkBool32", "alphaToCoverageEnable", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetAlphaToOneEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(alphaToOneEnable, settings, "VkBool32", "alphaToOneEnable", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetLogicOpEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 logicOpEnable) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(logicOpEnable, settings, "VkBool32", "logicOpEnable", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetColorBlendEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32* pColorBlendEnables) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(firstAttachment, settings, "uint32_t", "firstAttachment", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(attachmentCount, settings, "uint32_t", "attachmentCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pColorBlendEnables, attachmentCount, settings, "const VkBool32*", "pColorBlendEnables", "const VkBool32", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetColorBlendEquationEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT* pColorBlendEquations) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(firstAttachment, settings, "uint32_t", "firstAttachment", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(attachmentCount, settings, "uint32_t", "attachmentCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pColorBlendEquations, attachmentCount, settings, "const VkColorBlendEquationEXT*", "pColorBlendEquations", "const VkColorBlendEquationEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkColorBlendEquationEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetColorWriteMaskEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags* pColorWriteMasks) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(firstAttachment, settings, "uint32_t", "firstAttachment", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(attachmentCount, settings, "uint32_t", "attachmentCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pColorWriteMasks, attachmentCount, settings, "const VkColorComponentFlags*", "pColorWriteMasks", "const VkColorComponentFlags", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkColorComponentFlags); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetTessellationDomainOriginEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkTessellationDomainOrigin(domainOrigin, settings, "VkTessellationDomainOrigin", "domainOrigin", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetRasterizationStreamEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t rasterizationStream) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(rasterizationStream, settings, "uint32_t", "rasterizationStream", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetConservativeRasterizationModeEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkConservativeRasterizationModeEXT(conservativeRasterizationMode, settings, "VkConservativeRasterizationModeEXT", "conservativeRasterizationMode", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetExtraPrimitiveOverestimationSizeEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(extraPrimitiveOverestimationSize, settings, "float", "extraPrimitiveOverestimationSize", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetDepthClipEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 depthClipEnable) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(depthClipEnable, settings, "VkBool32", "depthClipEnable", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetSampleLocationsEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(sampleLocationsEnable, settings, "VkBool32", "sampleLocationsEnable", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetColorBlendAdvancedEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT* pColorBlendAdvanced) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(firstAttachment, settings, "uint32_t", "firstAttachment", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(attachmentCount, settings, "uint32_t", "attachmentCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pColorBlendAdvanced, attachmentCount, settings, "const VkColorBlendAdvancedEXT*", "pColorBlendAdvanced", "const VkColorBlendAdvancedEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkColorBlendAdvancedEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetProvokingVertexModeEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkProvokingVertexModeEXT(provokingVertexMode, settings, "VkProvokingVertexModeEXT", "provokingVertexMode", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetLineRasterizationModeEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkLineRasterizationMode(lineRasterizationMode, settings, "VkLineRasterizationModeEXT", "lineRasterizationMode", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetLineStippleEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(stippledLineEnable, settings, "VkBool32", "stippledLineEnable", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetDepthClipNegativeOneToOneEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(negativeOneToOne, settings, "VkBool32", "negativeOneToOne", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetViewportWScalingEnableNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(viewportWScalingEnable, settings, "VkBool32", "viewportWScalingEnable", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetViewportSwizzleNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV* pViewportSwizzles) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(firstViewport, settings, "uint32_t", "firstViewport", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(viewportCount, settings, "uint32_t", "viewportCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pViewportSwizzles, viewportCount, settings, "const VkViewportSwizzleNV*", "pViewportSwizzles", "const VkViewportSwizzleNV", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkViewportSwizzleNV); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetCoverageToColorEnableNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(coverageToColorEnable, settings, "VkBool32", "coverageToColorEnable", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetCoverageToColorLocationNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(coverageToColorLocation, settings, "uint32_t", "coverageToColorLocation", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetCoverageModulationModeNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkCoverageModulationModeNV(coverageModulationMode, settings, "VkCoverageModulationModeNV", "coverageModulationMode", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetCoverageModulationTableEnableNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(coverageModulationTableEnable, settings, "VkBool32", "coverageModulationTableEnable", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetCoverageModulationTableNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float* pCoverageModulationTable) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(coverageModulationTableCount, settings, "uint32_t", "coverageModulationTableCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pCoverageModulationTable, coverageModulationTableCount, settings, "const float*", "pCoverageModulationTable", "const float", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetShadingRateImageEnableNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(shadingRateImageEnable, settings, "VkBool32", "shadingRateImageEnable", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetRepresentativeFragmentTestEnableNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(representativeFragmentTestEnable, settings, "VkBool32", "representativeFragmentTestEnable", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetCoverageReductionModeNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkCoverageReductionModeNV(coverageReductionMode, settings, "VkCoverageReductionModeNV", "coverageReductionMode", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateTensorARM(ApiDumpInstance& dump_inst, VkDevice device, const VkTensorCreateInfoARM* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkTensorARM* pTensor) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkTensorCreateInfoARM*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkTensorCreateInfoARM); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pTensor, settings, "VkTensorARM*", "pTensor", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkTensorARM); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyTensorARM(ApiDumpInstance& dump_inst, VkDevice device, VkTensorARM tensor, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkTensorARM(tensor, settings, "VkTensorARM", "tensor", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateTensorViewARM(ApiDumpInstance& dump_inst, VkDevice device, const VkTensorViewCreateInfoARM* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkTensorViewARM* pView) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkTensorViewCreateInfoARM*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkTensorViewCreateInfoARM); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pView, settings, "VkTensorViewARM*", "pView", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkTensorViewARM); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyTensorViewARM(ApiDumpInstance& dump_inst, VkDevice device, VkTensorViewARM tensorView, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkTensorViewARM(tensorView, settings, "VkTensorViewARM", "tensorView", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetTensorMemoryRequirementsARM(ApiDumpInstance& dump_inst, VkDevice device, const VkTensorMemoryRequirementsInfoARM* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkTensorMemoryRequirementsInfoARM*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkTensorMemoryRequirementsInfoARM); + dump_separate_members(settings); + dump_pointer(pMemoryRequirements, settings, "VkMemoryRequirements2*", "pMemoryRequirements", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkBindTensorMemoryARM(ApiDumpInstance& dump_inst, VkDevice device, uint32_t bindInfoCount, const VkBindTensorMemoryInfoARM* pBindInfos) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(bindInfoCount, settings, "uint32_t", "bindInfoCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pBindInfos, bindInfoCount, settings, "const VkBindTensorMemoryInfoARM*", "pBindInfos", "const VkBindTensorMemoryInfoARM", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBindTensorMemoryInfoARM); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetDeviceTensorMemoryRequirementsARM(ApiDumpInstance& dump_inst, VkDevice device, const VkDeviceTensorMemoryRequirementsARM* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkDeviceTensorMemoryRequirementsARM*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDeviceTensorMemoryRequirementsARM); + dump_separate_members(settings); + dump_pointer(pMemoryRequirements, settings, "VkMemoryRequirements2*", "pMemoryRequirements", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdCopyTensorARM(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyTensorInfoARM* pCopyTensorInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCopyTensorInfo, settings, "const VkCopyTensorInfoARM*", "pCopyTensorInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyTensorInfoARM); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceExternalTensorPropertiesARM(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalTensorInfoARM* pExternalTensorInfo, VkExternalTensorPropertiesARM* pExternalTensorProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pExternalTensorInfo, settings, "const VkPhysicalDeviceExternalTensorInfoARM*", "pExternalTensorInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceExternalTensorInfoARM); + dump_separate_members(settings); + dump_pointer(pExternalTensorProperties, settings, "VkExternalTensorPropertiesARM*", "pExternalTensorProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkExternalTensorPropertiesARM); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetTensorOpaqueCaptureDescriptorDataARM(ApiDumpInstance& dump_inst, VkDevice device, const VkTensorCaptureDescriptorDataInfoARM* pInfo, void* pData) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkTensorCaptureDescriptorDataInfoARM*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkTensorCaptureDescriptorDataInfoARM); + dump_separate_members(settings); + dump_type(pData, settings, "void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetTensorViewOpaqueCaptureDescriptorDataARM(ApiDumpInstance& dump_inst, VkDevice device, const VkTensorViewCaptureDescriptorDataInfoARM* pInfo, void* pData) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkTensorViewCaptureDescriptorDataInfoARM*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkTensorViewCaptureDescriptorDataInfoARM); + dump_separate_members(settings); + dump_type(pData, settings, "void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetShaderModuleIdentifierEXT(ApiDumpInstance& dump_inst, VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT* pIdentifier) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkShaderModule(shaderModule, settings, "VkShaderModule", "shaderModule", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pIdentifier, settings, "VkShaderModuleIdentifierEXT*", "pIdentifier", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkShaderModuleIdentifierEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetShaderModuleCreateInfoIdentifierEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModuleIdentifierEXT* pIdentifier) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkShaderModuleCreateInfo*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkShaderModuleCreateInfo); + dump_separate_members(settings); + dump_pointer(pIdentifier, settings, "VkShaderModuleIdentifierEXT*", "pIdentifier", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkShaderModuleIdentifierEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, uint32_t* pFormatCount, VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pOpticalFlowImageFormatInfo, settings, "const VkOpticalFlowImageFormatInfoNV*", "pOpticalFlowImageFormatInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkOpticalFlowImageFormatInfoNV); + dump_separate_members(settings); + dump_pointer(pFormatCount, settings, "uint32_t*", "pFormatCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pImageFormatProperties, *pFormatCount, settings, "VkOpticalFlowImageFormatPropertiesNV*", "pImageFormatProperties", "VkOpticalFlowImageFormatPropertiesNV", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkOpticalFlowImageFormatPropertiesNV); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateOpticalFlowSessionNV(ApiDumpInstance& dump_inst, VkDevice device, const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkOpticalFlowSessionNV* pSession) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkOpticalFlowSessionCreateInfoNV*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkOpticalFlowSessionCreateInfoNV); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pSession, settings, "VkOpticalFlowSessionNV*", "pSession", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkOpticalFlowSessionNV); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyOpticalFlowSessionNV(ApiDumpInstance& dump_inst, VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkOpticalFlowSessionNV(session, settings, "VkOpticalFlowSessionNV", "session", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkBindOpticalFlowSessionImageNV(ApiDumpInstance& dump_inst, VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkOpticalFlowSessionNV(session, settings, "VkOpticalFlowSessionNV", "session", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkOpticalFlowSessionBindingPointNV(bindingPoint, settings, "VkOpticalFlowSessionBindingPointNV", "bindingPoint", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImageView(view, settings, "VkImageView", "view", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImageLayout(layout, settings, "VkImageLayout", "layout", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdOpticalFlowExecuteNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV* pExecuteInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkOpticalFlowSessionNV(session, settings, "VkOpticalFlowSessionNV", "session", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pExecuteInfo, settings, "const VkOpticalFlowExecuteInfoNV*", "pExecuteInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkOpticalFlowExecuteInfoNV); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkAntiLagUpdateAMD(ApiDumpInstance& dump_inst, VkDevice device, const VkAntiLagDataAMD* pData) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pData, settings, "const VkAntiLagDataAMD*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAntiLagDataAMD); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateShadersEXT(ApiDumpInstance& dump_inst, VkDevice device, uint32_t createInfoCount, const VkShaderCreateInfoEXT* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkShaderEXT* pShaders) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(createInfoCount, settings, "uint32_t", "createInfoCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pCreateInfos, createInfoCount, settings, "const VkShaderCreateInfoEXT*", "pCreateInfos", "const VkShaderCreateInfoEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkShaderCreateInfoEXT); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer_array(pShaders, createInfoCount, settings, "VkShaderEXT*", "pShaders", "VkShaderEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkShaderEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyShaderEXT(ApiDumpInstance& dump_inst, VkDevice device, VkShaderEXT shader, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkShaderEXT(shader, settings, "VkShaderEXT", "shader", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetShaderBinaryDataEXT(ApiDumpInstance& dump_inst, VkDevice device, VkShaderEXT shader, size_t* pDataSize, void* pData) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkShaderEXT(shader, settings, "VkShaderEXT", "shader", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pDataSize, settings, "size_t*", "pDataSize", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_type(pData, settings, "void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdBindShadersEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t stageCount, const VkShaderStageFlagBits* pStages, const VkShaderEXT* pShaders) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(stageCount, settings, "uint32_t", "stageCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pStages, stageCount, settings, "const VkShaderStageFlagBits*", "pStages", "const VkShaderStageFlagBits", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkShaderStageFlagBits); + dump_separate_members(settings); + dump_pointer_array(pShaders, stageCount, settings, "const VkShaderEXT*", "pShaders", "const VkShaderEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkShaderEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetDepthClampRangeEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkDepthClampModeEXT depthClampMode, const VkDepthClampRangeEXT* pDepthClampRange) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDepthClampModeEXT(depthClampMode, settings, "VkDepthClampModeEXT", "depthClampMode", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pDepthClampRange, settings, "const VkDepthClampRangeEXT*", "pDepthClampRange", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDepthClampRangeEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetFramebufferTilePropertiesQCOM(ApiDumpInstance& dump_inst, VkDevice device, VkFramebuffer framebuffer, uint32_t* pPropertiesCount, VkTilePropertiesQCOM* pProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkFramebuffer(framebuffer, settings, "VkFramebuffer", "framebuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pPropertiesCount, settings, "uint32_t*", "pPropertiesCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pProperties, *pPropertiesCount, settings, "VkTilePropertiesQCOM*", "pProperties", "VkTilePropertiesQCOM", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkTilePropertiesQCOM); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetDynamicRenderingTilePropertiesQCOM(ApiDumpInstance& dump_inst, VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pRenderingInfo, settings, "const VkRenderingInfo*", "pRenderingInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderingInfo); + dump_separate_members(settings); + dump_pointer(pProperties, settings, "VkTilePropertiesQCOM*", "pProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkTilePropertiesQCOM); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceCooperativeVectorPropertiesNV(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeVectorPropertiesNV* pProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pPropertyCount, settings, "uint32_t*", "pPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pProperties, *pPropertyCount, settings, "VkCooperativeVectorPropertiesNV*", "pProperties", "VkCooperativeVectorPropertiesNV", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCooperativeVectorPropertiesNV); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkConvertCooperativeVectorMatrixNV(ApiDumpInstance& dump_inst, VkDevice device, const VkConvertCooperativeVectorMatrixInfoNV* pInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkConvertCooperativeVectorMatrixInfoNV*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkConvertCooperativeVectorMatrixInfoNV); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdConvertCooperativeVectorMatrixNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t infoCount, const VkConvertCooperativeVectorMatrixInfoNV* pInfos) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(infoCount, settings, "uint32_t", "infoCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pInfos, infoCount, settings, "const VkConvertCooperativeVectorMatrixInfoNV*", "pInfos", "const VkConvertCooperativeVectorMatrixInfoNV", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkConvertCooperativeVectorMatrixInfoNV); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkSetLatencySleepModeNV(ApiDumpInstance& dump_inst, VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepModeInfoNV* pSleepModeInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkSwapchainKHR(swapchain, settings, "VkSwapchainKHR", "swapchain", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pSleepModeInfo, settings, "const VkLatencySleepModeInfoNV*", "pSleepModeInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkLatencySleepModeInfoNV); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkLatencySleepNV(ApiDumpInstance& dump_inst, VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepInfoNV* pSleepInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkSwapchainKHR(swapchain, settings, "VkSwapchainKHR", "swapchain", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pSleepInfo, settings, "const VkLatencySleepInfoNV*", "pSleepInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkLatencySleepInfoNV); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkSetLatencyMarkerNV(ApiDumpInstance& dump_inst, VkDevice device, VkSwapchainKHR swapchain, const VkSetLatencyMarkerInfoNV* pLatencyMarkerInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkSwapchainKHR(swapchain, settings, "VkSwapchainKHR", "swapchain", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pLatencyMarkerInfo, settings, "const VkSetLatencyMarkerInfoNV*", "pLatencyMarkerInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSetLatencyMarkerInfoNV); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetLatencyTimingsNV(ApiDumpInstance& dump_inst, VkDevice device, VkSwapchainKHR swapchain, VkGetLatencyMarkerInfoNV* pLatencyMarkerInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkSwapchainKHR(swapchain, settings, "VkSwapchainKHR", "swapchain", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pLatencyMarkerInfo, settings, "VkGetLatencyMarkerInfoNV*", "pLatencyMarkerInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkGetLatencyMarkerInfoNV); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkQueueNotifyOutOfBandNV(ApiDumpInstance& dump_inst, VkQueue queue, const VkOutOfBandQueueTypeInfoNV* pQueueTypeInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkQueue(queue, settings, "VkQueue", "queue", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pQueueTypeInfo, settings, "const VkOutOfBandQueueTypeInfoNV*", "pQueueTypeInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkOutOfBandQueueTypeInfoNV); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateDataGraphPipelinesARM(ApiDumpInstance& dump_inst, VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkDataGraphPipelineCreateInfoARM* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDeferredOperationKHR(deferredOperation, settings, "VkDeferredOperationKHR", "deferredOperation", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipelineCache(pipelineCache, settings, "VkPipelineCache", "pipelineCache", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(createInfoCount, settings, "uint32_t", "createInfoCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pCreateInfos, createInfoCount, settings, "const VkDataGraphPipelineCreateInfoARM*", "pCreateInfos", "const VkDataGraphPipelineCreateInfoARM", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDataGraphPipelineCreateInfoARM); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer_array(pPipelines, createInfoCount, settings, "VkPipeline*", "pPipelines", "VkPipeline", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipeline); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateDataGraphPipelineSessionARM(ApiDumpInstance& dump_inst, VkDevice device, const VkDataGraphPipelineSessionCreateInfoARM* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDataGraphPipelineSessionARM* pSession) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkDataGraphPipelineSessionCreateInfoARM*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDataGraphPipelineSessionCreateInfoARM); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pSession, settings, "VkDataGraphPipelineSessionARM*", "pSession", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDataGraphPipelineSessionARM); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetDataGraphPipelineSessionBindPointRequirementsARM(ApiDumpInstance& dump_inst, VkDevice device, const VkDataGraphPipelineSessionBindPointRequirementsInfoARM* pInfo, uint32_t* pBindPointRequirementCount, VkDataGraphPipelineSessionBindPointRequirementARM* pBindPointRequirements) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkDataGraphPipelineSessionBindPointRequirementsInfoARM*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDataGraphPipelineSessionBindPointRequirementsInfoARM); + dump_separate_members(settings); + dump_pointer(pBindPointRequirementCount, settings, "uint32_t*", "pBindPointRequirementCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pBindPointRequirements, *pBindPointRequirementCount, settings, "VkDataGraphPipelineSessionBindPointRequirementARM*", "pBindPointRequirements", "VkDataGraphPipelineSessionBindPointRequirementARM", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDataGraphPipelineSessionBindPointRequirementARM); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetDataGraphPipelineSessionMemoryRequirementsARM(ApiDumpInstance& dump_inst, VkDevice device, const VkDataGraphPipelineSessionMemoryRequirementsInfoARM* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkDataGraphPipelineSessionMemoryRequirementsInfoARM*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDataGraphPipelineSessionMemoryRequirementsInfoARM); + dump_separate_members(settings); + dump_pointer(pMemoryRequirements, settings, "VkMemoryRequirements2*", "pMemoryRequirements", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkBindDataGraphPipelineSessionMemoryARM(ApiDumpInstance& dump_inst, VkDevice device, uint32_t bindInfoCount, const VkBindDataGraphPipelineSessionMemoryInfoARM* pBindInfos) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(bindInfoCount, settings, "uint32_t", "bindInfoCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pBindInfos, bindInfoCount, settings, "const VkBindDataGraphPipelineSessionMemoryInfoARM*", "pBindInfos", "const VkBindDataGraphPipelineSessionMemoryInfoARM", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBindDataGraphPipelineSessionMemoryInfoARM); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyDataGraphPipelineSessionARM(ApiDumpInstance& dump_inst, VkDevice device, VkDataGraphPipelineSessionARM session, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDataGraphPipelineSessionARM(session, settings, "VkDataGraphPipelineSessionARM", "session", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdDispatchDataGraphARM(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkDataGraphPipelineSessionARM session, const VkDataGraphPipelineDispatchInfoARM* pInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDataGraphPipelineSessionARM(session, settings, "VkDataGraphPipelineSessionARM", "session", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkDataGraphPipelineDispatchInfoARM*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDataGraphPipelineDispatchInfoARM); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetDataGraphPipelineAvailablePropertiesARM(ApiDumpInstance& dump_inst, VkDevice device, const VkDataGraphPipelineInfoARM* pPipelineInfo, uint32_t* pPropertiesCount, VkDataGraphPipelinePropertyARM* pProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pPipelineInfo, settings, "const VkDataGraphPipelineInfoARM*", "pPipelineInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDataGraphPipelineInfoARM); + dump_separate_members(settings); + dump_pointer(pPropertiesCount, settings, "uint32_t*", "pPropertiesCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pProperties, *pPropertiesCount, settings, "VkDataGraphPipelinePropertyARM*", "pProperties", "VkDataGraphPipelinePropertyARM", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDataGraphPipelinePropertyARM); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetDataGraphPipelinePropertiesARM(ApiDumpInstance& dump_inst, VkDevice device, const VkDataGraphPipelineInfoARM* pPipelineInfo, uint32_t propertiesCount, VkDataGraphPipelinePropertyQueryResultARM* pProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pPipelineInfo, settings, "const VkDataGraphPipelineInfoARM*", "pPipelineInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDataGraphPipelineInfoARM); + dump_separate_members(settings); + dump_type(propertiesCount, settings, "uint32_t", "propertiesCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pProperties, propertiesCount, settings, "VkDataGraphPipelinePropertyQueryResultARM*", "pProperties", "VkDataGraphPipelinePropertyQueryResultARM", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDataGraphPipelinePropertyQueryResultARM); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pQueueFamilyDataGraphPropertyCount, VkQueueFamilyDataGraphPropertiesARM* pQueueFamilyDataGraphProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pQueueFamilyDataGraphPropertyCount, settings, "uint32_t*", "pQueueFamilyDataGraphPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pQueueFamilyDataGraphProperties, *pQueueFamilyDataGraphPropertyCount, settings, "VkQueueFamilyDataGraphPropertiesARM*", "pQueueFamilyDataGraphProperties", "VkQueueFamilyDataGraphPropertiesARM", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkQueueFamilyDataGraphPropertiesARM); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM* pQueueFamilyDataGraphProcessingEngineInfo, VkQueueFamilyDataGraphProcessingEnginePropertiesARM* pQueueFamilyDataGraphProcessingEngineProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pQueueFamilyDataGraphProcessingEngineInfo, settings, "const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM*", "pQueueFamilyDataGraphProcessingEngineInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM); + dump_separate_members(settings); + dump_pointer(pQueueFamilyDataGraphProcessingEngineProperties, settings, "VkQueueFamilyDataGraphProcessingEnginePropertiesARM*", "pQueueFamilyDataGraphProcessingEngineProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkQueueFamilyDataGraphProcessingEnginePropertiesARM); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetAttachmentFeedbackLoopEnableEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkImageAspectFlags(aspectMask, settings, "VkImageAspectFlags", "aspectMask", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} +#if defined(VK_USE_PLATFORM_SCREEN_QNX) + +template +void dump_params_vkGetScreenBufferPropertiesQNX(ApiDumpInstance& dump_inst, VkDevice device, const struct _screen_buffer* buffer, VkScreenBufferPropertiesQNX* pProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(buffer, settings, "const struct _screen_buffer*", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pProperties, settings, "VkScreenBufferPropertiesQNX*", "pProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkScreenBufferPropertiesQNX); + dump_post_params_formatting(settings); + flush(settings); + } +} +#endif // VK_USE_PLATFORM_SCREEN_QNX + +template +void dump_params_vkCmdBindTileMemoryQCOM(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkTileMemoryBindInfoQCOM* pTileMemoryBindInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pTileMemoryBindInfo, settings, "const VkTileMemoryBindInfoQCOM*", "pTileMemoryBindInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkTileMemoryBindInfoQCOM); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdDecompressMemoryEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkDecompressMemoryInfoEXT* pDecompressMemoryInfoEXT) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pDecompressMemoryInfoEXT, settings, "const VkDecompressMemoryInfoEXT*", "pDecompressMemoryInfoEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkDecompressMemoryInfoEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdDecompressMemoryIndirectCountEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkMemoryDecompressionMethodFlagsEXT decompressionMethod, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t maxDecompressionCount, uint32_t stride) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkMemoryDecompressionMethodFlagsEXT(decompressionMethod, settings, "VkMemoryDecompressionMethodFlagsEXT", "decompressionMethod", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type_hex(indirectCommandsAddress, settings, "VkDeviceAddress", "indirectCommandsAddress", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type_hex(indirectCommandsCountAddress, settings, "VkDeviceAddress", "indirectCommandsCountAddress", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(maxDecompressionCount, settings, "uint32_t", "maxDecompressionCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(stride, settings, "uint32_t", "stride", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateExternalComputeQueueNV(ApiDumpInstance& dump_inst, VkDevice device, const VkExternalComputeQueueCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkExternalComputeQueueNV* pExternalQueue) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkExternalComputeQueueCreateInfoNV*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkExternalComputeQueueCreateInfoNV); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pExternalQueue, settings, "VkExternalComputeQueueNV*", "pExternalQueue", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkExternalComputeQueueNV); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyExternalComputeQueueNV(ApiDumpInstance& dump_inst, VkDevice device, VkExternalComputeQueueNV externalQueue, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkExternalComputeQueueNV(externalQueue, settings, "VkExternalComputeQueueNV", "externalQueue", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetExternalComputeQueueDataNV(ApiDumpInstance& dump_inst, VkExternalComputeQueueNV externalQueue, VkExternalComputeQueueDataParamsNV* params, void* pData) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkExternalComputeQueueNV(externalQueue, settings, "VkExternalComputeQueueNV", "externalQueue", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(params, settings, "VkExternalComputeQueueDataParamsNV*", "params", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkExternalComputeQueueDataParamsNV); + dump_separate_members(settings); + dump_type(pData, settings, "void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetClusterAccelerationStructureBuildSizesNV(ApiDumpInstance& dump_inst, VkDevice device, const VkClusterAccelerationStructureInputInfoNV* pInfo, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkClusterAccelerationStructureInputInfoNV*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkClusterAccelerationStructureInputInfoNV); + dump_separate_members(settings); + dump_pointer(pSizeInfo, settings, "VkAccelerationStructureBuildSizesInfoKHR*", "pSizeInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureBuildSizesInfoKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdBuildClusterAccelerationStructureIndirectNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkClusterAccelerationStructureCommandsInfoNV* pCommandInfos) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCommandInfos, settings, "const VkClusterAccelerationStructureCommandsInfoNV*", "pCommandInfos", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkClusterAccelerationStructureCommandsInfoNV); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetPartitionedAccelerationStructuresBuildSizesNV(ApiDumpInstance& dump_inst, VkDevice device, const VkPartitionedAccelerationStructureInstancesInputNV* pInfo, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkPartitionedAccelerationStructureInstancesInputNV*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPartitionedAccelerationStructureInstancesInputNV); + dump_separate_members(settings); + dump_pointer(pSizeInfo, settings, "VkAccelerationStructureBuildSizesInfoKHR*", "pSizeInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureBuildSizesInfoKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdBuildPartitionedAccelerationStructuresNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkBuildPartitionedAccelerationStructureInfoNV* pBuildInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pBuildInfo, settings, "const VkBuildPartitionedAccelerationStructureInfoNV*", "pBuildInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBuildPartitionedAccelerationStructureInfoNV); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetGeneratedCommandsMemoryRequirementsEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoEXT* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkGeneratedCommandsMemoryRequirementsInfoEXT*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkGeneratedCommandsMemoryRequirementsInfoEXT); + dump_separate_members(settings); + dump_pointer(pMemoryRequirements, settings, "VkMemoryRequirements2*", "pMemoryRequirements", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryRequirements2); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdPreprocessGeneratedCommandsEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo, VkCommandBuffer stateCommandBuffer) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pGeneratedCommandsInfo, settings, "const VkGeneratedCommandsInfoEXT*", "pGeneratedCommandsInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkGeneratedCommandsInfoEXT); + dump_separate_members(settings); + dump_VkCommandBuffer(stateCommandBuffer, settings, "VkCommandBuffer", "stateCommandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdExecuteGeneratedCommandsEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(isPreprocessed, settings, "VkBool32", "isPreprocessed", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pGeneratedCommandsInfo, settings, "const VkGeneratedCommandsInfoEXT*", "pGeneratedCommandsInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkGeneratedCommandsInfoEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateIndirectCommandsLayoutEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkIndirectCommandsLayoutCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutEXT* pIndirectCommandsLayout) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkIndirectCommandsLayoutCreateInfoEXT*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkIndirectCommandsLayoutCreateInfoEXT); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pIndirectCommandsLayout, settings, "VkIndirectCommandsLayoutEXT*", "pIndirectCommandsLayout", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkIndirectCommandsLayoutEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyIndirectCommandsLayoutEXT(ApiDumpInstance& dump_inst, VkDevice device, VkIndirectCommandsLayoutEXT indirectCommandsLayout, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkIndirectCommandsLayoutEXT(indirectCommandsLayout, settings, "VkIndirectCommandsLayoutEXT", "indirectCommandsLayout", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateIndirectExecutionSetEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkIndirectExecutionSetCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectExecutionSetEXT* pIndirectExecutionSet) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkIndirectExecutionSetCreateInfoEXT*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkIndirectExecutionSetCreateInfoEXT); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pIndirectExecutionSet, settings, "VkIndirectExecutionSetEXT*", "pIndirectExecutionSet", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkIndirectExecutionSetEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyIndirectExecutionSetEXT(ApiDumpInstance& dump_inst, VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkIndirectExecutionSetEXT(indirectExecutionSet, settings, "VkIndirectExecutionSetEXT", "indirectExecutionSet", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkUpdateIndirectExecutionSetPipelineEXT(ApiDumpInstance& dump_inst, VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, const VkWriteIndirectExecutionSetPipelineEXT* pExecutionSetWrites) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkIndirectExecutionSetEXT(indirectExecutionSet, settings, "VkIndirectExecutionSetEXT", "indirectExecutionSet", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(executionSetWriteCount, settings, "uint32_t", "executionSetWriteCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pExecutionSetWrites, executionSetWriteCount, settings, "const VkWriteIndirectExecutionSetPipelineEXT*", "pExecutionSetWrites", "const VkWriteIndirectExecutionSetPipelineEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkWriteIndirectExecutionSetPipelineEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkUpdateIndirectExecutionSetShaderEXT(ApiDumpInstance& dump_inst, VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, const VkWriteIndirectExecutionSetShaderEXT* pExecutionSetWrites) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkIndirectExecutionSetEXT(indirectExecutionSet, settings, "VkIndirectExecutionSetEXT", "indirectExecutionSet", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(executionSetWriteCount, settings, "uint32_t", "executionSetWriteCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pExecutionSetWrites, executionSetWriteCount, settings, "const VkWriteIndirectExecutionSetShaderEXT*", "pExecutionSetWrites", "const VkWriteIndirectExecutionSetShaderEXT", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkWriteIndirectExecutionSetShaderEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} +#if defined(VK_USE_PLATFORM_OHOS) + +template +void dump_params_vkCreateSurfaceOHOS(ApiDumpInstance& dump_inst, VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkInstance(instance, settings, "VkInstance", "instance", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkSurfaceCreateInfoOHOS*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceCreateInfoOHOS); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pSurface, settings, "VkSurfaceKHR*", "pSurface", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkSurfaceKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} +#endif // VK_USE_PLATFORM_OHOS + +template +void dump_params_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixFlexibleDimensionsPropertiesNV* pProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pPropertyCount, settings, "uint32_t*", "pPropertyCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pProperties, *pPropertyCount, settings, "VkCooperativeMatrixFlexibleDimensionsPropertiesNV*", "pProperties", "VkCooperativeMatrixFlexibleDimensionsPropertiesNV", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCooperativeMatrixFlexibleDimensionsPropertiesNV); + dump_post_params_formatting(settings); + flush(settings); + } +} +#if defined(VK_USE_PLATFORM_METAL_EXT) + +template +void dump_params_vkGetMemoryMetalHandleEXT(ApiDumpInstance& dump_inst, VkDevice device, const VkMemoryGetMetalHandleInfoEXT* pGetMetalHandleInfo, void** pHandle) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pGetMetalHandleInfo, settings, "const VkMemoryGetMetalHandleInfoEXT*", "pGetMetalHandleInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryGetMetalHandleInfoEXT); + dump_separate_members(settings); + dump_type(pHandle, settings, "void**", "pHandle", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetMemoryMetalHandlePropertiesEXT(ApiDumpInstance& dump_inst, VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHandle, VkMemoryMetalHandlePropertiesEXT* pMemoryMetalHandleProperties) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkExternalMemoryHandleTypeFlagBits(handleType, settings, "VkExternalMemoryHandleTypeFlagBits", "handleType", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(pHandle, settings, "const void*", "pHandle", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pMemoryMetalHandleProperties, settings, "VkMemoryMetalHandlePropertiesEXT*", "pMemoryMetalHandleProperties", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkMemoryMetalHandlePropertiesEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} +#endif // VK_USE_PLATFORM_METAL_EXT + +template +void dump_params_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM(ApiDumpInstance& dump_inst, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterARM* pCounters, VkPerformanceCounterDescriptionARM* pCounterDescriptions) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkPhysicalDevice(physicalDevice, settings, "VkPhysicalDevice", "physicalDevice", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(queueFamilyIndex, settings, "uint32_t", "queueFamilyIndex", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCounterCount, settings, "uint32_t*", "pCounterCount", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pCounters, *pCounterCount, settings, "VkPerformanceCounterARM*", "pCounters", "VkPerformanceCounterARM", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPerformanceCounterARM); + dump_separate_members(settings); + dump_pointer_array(pCounterDescriptions, *pCounterCount, settings, "VkPerformanceCounterDescriptionARM*", "pCounterDescriptions", "VkPerformanceCounterDescriptionARM", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPerformanceCounterDescriptionARM); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdEndRendering2EXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkRenderingEndInfoKHR* pRenderingEndInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pRenderingEndInfo, settings, "const VkRenderingEndInfoKHR*", "pRenderingEndInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRenderingEndInfoKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdBeginCustomResolveEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkBeginCustomResolveInfoEXT* pBeginCustomResolveInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pBeginCustomResolveInfo, settings, "const VkBeginCustomResolveInfoEXT*", "pBeginCustomResolveInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkBeginCustomResolveInfoEXT); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetComputeOccupancyPriorityNV(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkComputeOccupancyPriorityParametersNV* pParameters) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pParameters, settings, "const VkComputeOccupancyPriorityParametersNV*", "pParameters", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkComputeOccupancyPriorityParametersNV); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateAccelerationStructureKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pCreateInfo, settings, "const VkAccelerationStructureCreateInfoKHR*", "pCreateInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureCreateInfoKHR); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer(pAccelerationStructure, settings, "VkAccelerationStructureKHR*", "pAccelerationStructure", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkDestroyAccelerationStructureKHR(ApiDumpInstance& dump_inst, VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks* pAllocator) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkAccelerationStructureKHR(accelerationStructure, settings, "VkAccelerationStructureKHR", "accelerationStructure", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdBuildAccelerationStructuresKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(infoCount, settings, "uint32_t", "infoCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pInfos, infoCount, settings, "const VkAccelerationStructureBuildGeometryInfoKHR*", "pInfos", "const VkAccelerationStructureBuildGeometryInfoKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureBuildGeometryInfoKHR); + dump_separate_members(settings); + dump_double_pointer_array(ppBuildRangeInfos, infoCount, settings, "const VkAccelerationStructureBuildRangeInfoKHR* const*", "ppBuildRangeInfos", "const VkAccelerationStructureBuildRangeInfoKHR*", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureBuildRangeInfoKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdBuildAccelerationStructuresIndirectKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkDeviceAddress* pIndirectDeviceAddresses, const uint32_t* pIndirectStrides, const uint32_t* const* ppMaxPrimitiveCounts) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(infoCount, settings, "uint32_t", "infoCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pInfos, infoCount, settings, "const VkAccelerationStructureBuildGeometryInfoKHR*", "pInfos", "const VkAccelerationStructureBuildGeometryInfoKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureBuildGeometryInfoKHR); + dump_separate_members(settings); + dump_pointer_array(pIndirectDeviceAddresses, infoCount, settings, "const VkDeviceAddress*", "pIndirectDeviceAddresses", "const VkDeviceAddress", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(pIndirectStrides, infoCount, settings, "const uint32_t*", "pIndirectStrides", "const uint32_t", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer_array(ppMaxPrimitiveCounts, infoCount, settings, "const uint32_t* const*", "ppMaxPrimitiveCounts", "const uint32_t*", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkBuildAccelerationStructuresKHR(ApiDumpInstance& dump_inst, VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDeferredOperationKHR(deferredOperation, settings, "VkDeferredOperationKHR", "deferredOperation", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(infoCount, settings, "uint32_t", "infoCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pInfos, infoCount, settings, "const VkAccelerationStructureBuildGeometryInfoKHR*", "pInfos", "const VkAccelerationStructureBuildGeometryInfoKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureBuildGeometryInfoKHR); + dump_separate_members(settings); + dump_double_pointer_array(ppBuildRangeInfos, infoCount, settings, "const VkAccelerationStructureBuildRangeInfoKHR* const*", "ppBuildRangeInfos", "const VkAccelerationStructureBuildRangeInfoKHR*", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureBuildRangeInfoKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCopyAccelerationStructureKHR(ApiDumpInstance& dump_inst, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR* pInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDeferredOperationKHR(deferredOperation, settings, "VkDeferredOperationKHR", "deferredOperation", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkCopyAccelerationStructureInfoKHR*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyAccelerationStructureInfoKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCopyAccelerationStructureToMemoryKHR(ApiDumpInstance& dump_inst, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDeferredOperationKHR(deferredOperation, settings, "VkDeferredOperationKHR", "deferredOperation", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkCopyAccelerationStructureToMemoryInfoKHR*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyAccelerationStructureToMemoryInfoKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCopyMemoryToAccelerationStructureKHR(ApiDumpInstance& dump_inst, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDeferredOperationKHR(deferredOperation, settings, "VkDeferredOperationKHR", "deferredOperation", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkCopyMemoryToAccelerationStructureInfoKHR*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyMemoryToAccelerationStructureInfoKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkWriteAccelerationStructuresPropertiesKHR(ApiDumpInstance& dump_inst, VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, size_t dataSize, void* pData, size_t stride) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(accelerationStructureCount, settings, "uint32_t", "accelerationStructureCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pAccelerationStructures, accelerationStructureCount, settings, "const VkAccelerationStructureKHR*", "pAccelerationStructures", "const VkAccelerationStructureKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureKHR); + dump_separate_members(settings); + dump_VkQueryType(queryType, settings, "VkQueryType", "queryType", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(dataSize, settings, "size_t", "dataSize", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(pData, settings, "void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(stride, settings, "size_t", "stride", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdCopyAccelerationStructureKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR* pInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkCopyAccelerationStructureInfoKHR*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyAccelerationStructureInfoKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdCopyAccelerationStructureToMemoryKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkCopyAccelerationStructureToMemoryInfoKHR*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyAccelerationStructureToMemoryInfoKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdCopyMemoryToAccelerationStructureKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkCopyMemoryToAccelerationStructureInfoKHR*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkCopyMemoryToAccelerationStructureInfoKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetAccelerationStructureDeviceAddressKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pInfo, settings, "const VkAccelerationStructureDeviceAddressInfoKHR*", "pInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureDeviceAddressInfoKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdWriteAccelerationStructuresPropertiesKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(accelerationStructureCount, settings, "uint32_t", "accelerationStructureCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pAccelerationStructures, accelerationStructureCount, settings, "const VkAccelerationStructureKHR*", "pAccelerationStructures", "const VkAccelerationStructureKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureKHR); + dump_separate_members(settings); + dump_VkQueryType(queryType, settings, "VkQueryType", "queryType", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkQueryPool(queryPool, settings, "VkQueryPool", "queryPool", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(firstQuery, settings, "uint32_t", "firstQuery", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetDeviceAccelerationStructureCompatibilityKHR(ApiDumpInstance& dump_inst, VkDevice device, const VkAccelerationStructureVersionInfoKHR* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pVersionInfo, settings, "const VkAccelerationStructureVersionInfoKHR*", "pVersionInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureVersionInfoKHR); + dump_separate_members(settings); + dump_pointer(pCompatibility, settings, "VkAccelerationStructureCompatibilityKHR*", "pCompatibility", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureCompatibilityKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetAccelerationStructureBuildSizesKHR(ApiDumpInstance& dump_inst, VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkAccelerationStructureBuildTypeKHR(buildType, settings, "VkAccelerationStructureBuildTypeKHR", "buildType", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pBuildInfo, settings, "const VkAccelerationStructureBuildGeometryInfoKHR*", "pBuildInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureBuildGeometryInfoKHR); + dump_separate_members(settings); + dump_pointer_array(pMaxPrimitiveCounts, pBuildInfo->geometryCount, settings, "const uint32_t*", "pMaxPrimitiveCounts", "const uint32_t", (Format == ApiDumpFormat::Json ? 4 : 1), dump_type); + dump_separate_members(settings); + dump_pointer(pSizeInfo, settings, "VkAccelerationStructureBuildSizesInfoKHR*", "pSizeInfo", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAccelerationStructureBuildSizesInfoKHR); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdTraceRaysKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pRaygenShaderBindingTable, settings, "const VkStridedDeviceAddressRegionKHR*", "pRaygenShaderBindingTable", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkStridedDeviceAddressRegionKHR); + dump_separate_members(settings); + dump_pointer(pMissShaderBindingTable, settings, "const VkStridedDeviceAddressRegionKHR*", "pMissShaderBindingTable", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkStridedDeviceAddressRegionKHR); + dump_separate_members(settings); + dump_pointer(pHitShaderBindingTable, settings, "const VkStridedDeviceAddressRegionKHR*", "pHitShaderBindingTable", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkStridedDeviceAddressRegionKHR); + dump_separate_members(settings); + dump_pointer(pCallableShaderBindingTable, settings, "const VkStridedDeviceAddressRegionKHR*", "pCallableShaderBindingTable", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkStridedDeviceAddressRegionKHR); + dump_separate_members(settings); + dump_type(width, settings, "uint32_t", "width", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(height, settings, "uint32_t", "height", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(depth, settings, "uint32_t", "depth", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCreateRayTracingPipelinesKHR(ApiDumpInstance& dump_inst, VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkDeferredOperationKHR(deferredOperation, settings, "VkDeferredOperationKHR", "deferredOperation", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipelineCache(pipelineCache, settings, "VkPipelineCache", "pipelineCache", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(createInfoCount, settings, "uint32_t", "createInfoCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer_array(pCreateInfos, createInfoCount, settings, "const VkRayTracingPipelineCreateInfoKHR*", "pCreateInfos", "const VkRayTracingPipelineCreateInfoKHR", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkRayTracingPipelineCreateInfoKHR); + dump_separate_members(settings); + dump_pointer(pAllocator, settings, "const VkAllocationCallbacks*", "pAllocator", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkAllocationCallbacks); + dump_separate_members(settings); + dump_pointer_array(pPipelines, createInfoCount, settings, "VkPipeline*", "pPipelines", "VkPipeline", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkPipeline); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(ApiDumpInstance& dump_inst, VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipeline(pipeline, settings, "VkPipeline", "pipeline", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(firstGroup, settings, "uint32_t", "firstGroup", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(groupCount, settings, "uint32_t", "groupCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(dataSize, settings, "size_t", "dataSize", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(pData, settings, "void*", "pData", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdTraceRaysIndirectKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_pointer(pRaygenShaderBindingTable, settings, "const VkStridedDeviceAddressRegionKHR*", "pRaygenShaderBindingTable", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkStridedDeviceAddressRegionKHR); + dump_separate_members(settings); + dump_pointer(pMissShaderBindingTable, settings, "const VkStridedDeviceAddressRegionKHR*", "pMissShaderBindingTable", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkStridedDeviceAddressRegionKHR); + dump_separate_members(settings); + dump_pointer(pHitShaderBindingTable, settings, "const VkStridedDeviceAddressRegionKHR*", "pHitShaderBindingTable", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkStridedDeviceAddressRegionKHR); + dump_separate_members(settings); + dump_pointer(pCallableShaderBindingTable, settings, "const VkStridedDeviceAddressRegionKHR*", "pCallableShaderBindingTable", (Format == ApiDumpFormat::Json ? 4 : 1), dump_VkStridedDeviceAddressRegionKHR); + dump_separate_members(settings); + dump_type_hex(indirectDeviceAddress, settings, "VkDeviceAddress", "indirectDeviceAddress", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkGetRayTracingShaderGroupStackSizeKHR(ApiDumpInstance& dump_inst, VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkDevice(device, settings, "VkDevice", "device", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkPipeline(pipeline, settings, "VkPipeline", "pipeline", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(group, settings, "uint32_t", "group", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkShaderGroupShaderKHR(groupShader, settings, "VkShaderGroupShaderKHR", "groupShader", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdSetRayTracingPipelineStackSizeKHR(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t pipelineStackSize) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(pipelineStackSize, settings, "uint32_t", "pipelineStackSize", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdDrawMeshTasksEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(groupCountX, settings, "uint32_t", "groupCountX", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(groupCountY, settings, "uint32_t", "groupCountY", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(groupCountZ, settings, "uint32_t", "groupCountZ", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdDrawMeshTasksIndirectEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(buffer, settings, "VkBuffer", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(offset, settings, "VkDeviceSize", "offset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(drawCount, settings, "uint32_t", "drawCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(stride, settings, "uint32_t", "stride", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +template +void dump_params_vkCmdDrawMeshTasksIndirectCountEXT(ApiDumpInstance& dump_inst, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { + const ApiDumpSettings& settings(dump_inst.settings()); + if (settings.showParams()) { + dump_pre_params_formatting(settings); + dump_VkCommandBuffer(commandBuffer, settings, "VkCommandBuffer", "commandBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(buffer, settings, "VkBuffer", "buffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(offset, settings, "VkDeviceSize", "offset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_VkBuffer(countBuffer, settings, "VkBuffer", "countBuffer", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(countBufferOffset, settings, "VkDeviceSize", "countBufferOffset", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(maxDrawCount, settings, "uint32_t", "maxDrawCount", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_separate_members(settings); + dump_type(stride, settings, "uint32_t", "stride", (Format == ApiDumpFormat::Json ? 4 : 1)); + dump_post_params_formatting(settings); + flush(settings); + } +} + +//========================== Type Implementations =========================// + +template +void dump_return_value_VkDeviceAddress(const VkDeviceAddress& address, const ApiDumpSettings& settings) { + dump_value_hex(settings, static_cast(address)); +} diff --git a/layersvt/json/VkLayer_CPUTiming.json.in b/layersvt/json/VkLayer_CPUTiming.json.in index 50b83e9956..caa24d0b84 100644 --- a/layersvt/json/VkLayer_CPUTiming.json.in +++ b/layersvt/json/VkLayer_CPUTiming.json.in @@ -1,7 +1,7 @@ { "file_format_version" : "1.2.0", "layer": { - "name": "VK_LAYER_CPUTiming", + "name": "CPUTiming", "type": "GLOBAL", "library_path": "@JSON_LIBRARY_PATH@", "api_version": "@JSON_VERSION@", diff --git a/scripts/generate_source.py b/scripts/generate_source.py index 86c291b50b..5a01b81e0e 100755 --- a/scripts/generate_source.py +++ b/scripts/generate_source.py @@ -76,6 +76,14 @@ def RunGenerators(api: str, registry: str, video_registry: str, directory: str, 'generator' : ApiDumpGenerator, 'genCombined': True, }, + 'cputiming_dispatch.h' : { + 'generator' : ApiDumpGenerator, + 'genCombined': True, + }, + 'cputiming_implementation.h' : { + 'generator' : ApiDumpGenerator, + 'genCombined': True, + }, } unknownTargets = [x for x in (targetFilter if targetFilter else []) if x not in generators.keys()] diff --git a/scripts/generators/api_dump_generator.py b/scripts/generators/api_dump_generator.py index 7f4a84b725..b499b83dea 100644 --- a/scripts/generators/api_dump_generator.py +++ b/scripts/generators/api_dump_generator.py @@ -335,9 +335,9 @@ def generate(self): self.build_vulkan_defined_type_set() self.build_only_use_as_pointer_types() self.generate_copyright() - if self.filename == 'api_dump_dispatch.h': + if self.filename == 'api_dump_dispatch.h' or self.filename == 'cputiming_dispatch.h': self.generate_dispatch_codegen() - elif self.filename == 'api_dump_implementation.h': + elif self.filename == 'api_dump_implementation.h' or self.filename == 'cputiming_implementation.h': self.generate_implementation() @@ -368,8 +368,13 @@ def generate_copyright(self): def generate_dispatch_codegen(self): - self.write('''#include "api_dump_handwritten_functions.h" -#include "timer.h" + if 'cputiming_dispatch.h' in self.genOpts.filename: + self.write('#include "cputiming_handwritten_functions.h"') + else: + self.write('#include "api_dump_handwritten_functions.h"') + self.write('\n#include "timer.h"') + + self.write(''' // Autogen instance functions ''') @@ -607,9 +612,13 @@ def generate_implementation(self): settings.stream() << object; bool is_first = true;''') for field in bitmask.flags: + if field.protect: + self.write(f'#if defined({field.protect})') self.write(f'if(object {"==" if field.zero or field.multiBit else "&"} {field.name}) {{') self.write(f'settings.stream() << (is_first ? \" (\" : \" | \") << "{field.name}"; is_first = false;') self.write('}') + if field.protect: + self.write('#endif') self.write(''' if(!is_first) settings.stream() << ")"; From 968d85d3cfe538c41d9669870ee29153f49e6d4c Mon Sep 17 00:00:00 2001 From: Emre Kultursay Date: Thu, 26 Feb 2026 12:34:55 -0800 Subject: [PATCH 07/14] Use android_log_print on Android --- layersvt/timer.h | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/layersvt/timer.h b/layersvt/timer.h index ec81ecfff1..db7df7c126 100644 --- a/layersvt/timer.h +++ b/layersvt/timer.h @@ -21,6 +21,10 @@ #include #include +#ifdef __ANDROID__ +#include +#endif + class Timer { public: explicit Timer(const char* name) : name_(name), start_(std::chrono::high_resolution_clock::now()) {} @@ -28,7 +32,11 @@ class Timer { ~Timer() { auto end = std::chrono::high_resolution_clock::now(); auto duration = std::chrono::duration_cast(end - start_).count(); +#ifdef __ANDROID__ + __android_log_print(ANDROID_LOG_ERROR, "CPUTiming", "%s: %lld ns", name_.c_str(), (long long)duration); +#else std::cout << name_ << ": " << duration << " ns" << std::endl; +#endif } private: From e36beca9c9460398c4d8dd5046ccaafdff2124c6 Mon Sep 17 00:00:00 2001 From: Emre Kultursay Date: Thu, 26 Feb 2026 16:10:24 -0800 Subject: [PATCH 08/14] Emit Perfetto events on start/end of APIs --- layersvt/CMakeLists.txt | 6 +- layersvt/cputiming_handwritten_functions.h | 6 + layersvt/perfetto/README.md | 13 + layersvt/perfetto/perfetto.cc | 73089 +++++++ layersvt/perfetto/perfetto.h | 190143 ++++++++++++++++++ layersvt/perfetto/perfetto_helpers.cpp | 14 + layersvt/perfetto/perfetto_helpers.h | 13 + layersvt/perfetto/update_perfetto_sdk.py | 105 + layersvt/timer.h | 25 +- 9 files changed, 263404 insertions(+), 10 deletions(-) create mode 100644 layersvt/perfetto/README.md create mode 100644 layersvt/perfetto/perfetto.cc create mode 100644 layersvt/perfetto/perfetto.h create mode 100644 layersvt/perfetto/perfetto_helpers.cpp create mode 100644 layersvt/perfetto/perfetto_helpers.h create mode 100755 layersvt/perfetto/update_perfetto_sdk.py diff --git a/layersvt/CMakeLists.txt b/layersvt/CMakeLists.txt index 7754490a51..0f2659185e 100644 --- a/layersvt/CMakeLists.txt +++ b/layersvt/CMakeLists.txt @@ -68,6 +68,8 @@ if(BUILD_APIDUMP) api_dump_layer.md json/VkLayer_api_dump.json.in ../scripts/generators/api_dump_generator.py + perfetto/perfetto.cc + perfetto/perfetto_helpers.cpp ) target_include_directories(VkLayer_api_dump PRIVATE @@ -128,6 +130,8 @@ if(BUILD_CPUTIMING) generated/cputiming_implementation.h api_dump.h cputiming_handwritten_functions.h + perfetto/perfetto.cc + perfetto/perfetto_helpers.cpp ../scripts/generators/api_dump_generator.py vk_layer_table.cpp vk_layer_table.h @@ -164,7 +168,7 @@ foreach(layer ${TOOL_LAYERS}) target_link_Libraries(${layer} PRIVATE Vulkan::Headers Vulkan::UtilityHeaders Vulkan::LayerSettings) if (ANDROID) - target_link_Libraries(${layer} PRIVATE log android) + target_link_Libraries(${layer} PRIVATE log android atomic) endif() target_include_directories(${layer} PRIVATE .) diff --git a/layersvt/cputiming_handwritten_functions.h b/layersvt/cputiming_handwritten_functions.h index e97db7d969..b8d1ec17f3 100644 --- a/layersvt/cputiming_handwritten_functions.h +++ b/layersvt/cputiming_handwritten_functions.h @@ -27,11 +27,17 @@ #include "generated/cputiming_implementation.h" #include "timer.h" +#include "perfetto/perfetto_helpers.h" + +#include + +static std::once_flag g_perfetto_init_flag; extern "C" { VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) { + std::call_once(g_perfetto_init_flag, []() { InitializePerfetto(); }); Timer timer("vkCreateInstance"); #if defined(_WIN32) && defined(_CRTDBG_MODE_FILE) #if !defined(NDEBUG) diff --git a/layersvt/perfetto/README.md b/layersvt/perfetto/README.md new file mode 100644 index 0000000000..6b7d81b7aa --- /dev/null +++ b/layersvt/perfetto/README.md @@ -0,0 +1,13 @@ +# Perfetto SDK + +The files `perfetto.cc` and `perfetto.h` in this directory are the **Amalgamated Perfetto SDK**. + +- **Version**: v53.0 +- **Source**: https://github.com/google/perfetto/archive/refs/tags/v53.0.zip +- **Files**: `sdk/perfetto.cc` and `sdk/perfetto.h` from the release archive. + +## Updating +To update the SDK: +1. Download the latest release zip from the [Perfetto GitHub Releases](https://github.com/google/perfetto/releases). +2. Extract `sdk/perfetto.cc` and `sdk/perfetto.h`. +3. Replace the files in this directory. diff --git a/layersvt/perfetto/perfetto.cc b/layersvt/perfetto/perfetto.cc new file mode 100644 index 0000000000..c122bae764 --- /dev/null +++ b/layersvt/perfetto/perfetto.cc @@ -0,0 +1,73089 @@ +// Copyright (C) 2019 The Android Open Source Project +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// This file is automatically generated by gen_amalgamated. Do not edit. + +// gen_amalgamated: predefined macros +#if !defined(PERFETTO_IMPLEMENTATION) +#define PERFETTO_IMPLEMENTATION +#endif +#include "perfetto.h" +// gen_amalgamated begin source: src/base/default_platform.cc +// gen_amalgamated begin header: include/perfetto/ext/base/platform.h +/* + * Copyright (C) 2023 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef INCLUDE_PERFETTO_EXT_BASE_PLATFORM_H_ +#define INCLUDE_PERFETTO_EXT_BASE_PLATFORM_H_ + +namespace perfetto { +namespace base { +namespace platform { + +// Executed before entering a syscall (e.g. poll, read, write etc) which might +// block. +// This is overridden in Google internal builds for dealing with userspace +// scheduling. +void BeforeMaybeBlockingSyscall(); + +// Executed after entering a syscall (e.g. poll, read, write etc) which might +// block. +// This is overridden in Google internal builds for dealing with userspace +// scheduling. +void AfterMaybeBlockingSyscall(); + +} // namespace platform +} // namespace base +} // namespace perfetto + +#endif // INCLUDE_PERFETTO_EXT_BASE_PLATFORM_H_ +/* + * Copyright (C) 2023 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// gen_amalgamated expanded: #include "perfetto/ext/base/platform.h" + +namespace perfetto { +namespace base { +namespace platform { + +// This is a no-op outside of Google3 where we have some custom logic to deal +// with the userspace scheduler. +void BeforeMaybeBlockingSyscall() {} + +// This is a no-op outside of Google3 where we have some custom logic to deal +// with the userspace scheduler. +void AfterMaybeBlockingSyscall() {} + +} // namespace platform +} // namespace base +} // namespace perfetto +// gen_amalgamated begin source: src/base/android_utils.cc +// gen_amalgamated begin header: include/perfetto/ext/base/android_utils.h +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef INCLUDE_PERFETTO_EXT_BASE_ANDROID_UTILS_H_ +#define INCLUDE_PERFETTO_EXT_BASE_ANDROID_UTILS_H_ + +#include +#include +#include + +// gen_amalgamated expanded: #include "perfetto/base/build_config.h" + +namespace perfetto { +namespace base { + +#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) + +// Returns the value of the Android system property named `name`. If the +// property does not exist, returns an empty string (a non-existing property is +// the same as a property with an empty value for this API). +std::string GetAndroidProp(const char* name); + +#endif // PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) + +struct Utsname { + std::string sysname; + std::string version; + std::string machine; + std::string release; +}; + +struct SystemInfo { + std::optional timezone_off_mins; + std::optional utsname_info; + std::optional page_size; + std::optional num_cpus; + std::string android_build_fingerprint; + std::string android_device_manufacturer; + std::optional android_sdk_version; + std::string android_soc_model; + std::string android_guest_soc_model; + std::string android_hardware_revision; + std::string android_storage_model; + std::string android_ram_model; + std::string android_serial_console; +}; + +// Returns the device's utsname information. +Utsname GetUtsname(); + +// Returns the device's system information. +SystemInfo GetSystemInfo(); + +// Returns the perfetto machine name. The PERFETTO_MACHINE_NAME env variable +// has the highest precedence in setting the machine name. In Android systems, +// if the env variable isn't set then the traced.machine_name system property +// is used. If no value is externally set, then the OS system name +// (see `uname -s`) is used as the default machine name. +std::string GetPerfettoMachineName(); + +} // namespace base +} // namespace perfetto + +#endif // INCLUDE_PERFETTO_EXT_BASE_ANDROID_UTILS_H_ +// gen_amalgamated begin header: include/perfetto/ext/base/string_utils.h +// gen_amalgamated begin header: include/perfetto/ext/base/string_view.h +// gen_amalgamated begin header: include/perfetto/ext/base/fnv_hash.h +/* + * Copyright (C) 2019 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef INCLUDE_PERFETTO_EXT_BASE_FNV_HASH_H_ +#define INCLUDE_PERFETTO_EXT_BASE_FNV_HASH_H_ + +#include +#include +#include +#include +#include + +namespace perfetto::base { + +// A helper class which computes a 64-bit hash of the input data. +// The algorithm used is FNV-1a as it is fast and easy to implement and has +// relatively few collisions. +// WARNING: This hash function should not be used for any cryptographic purpose. +class FnvHasher { + public: + // Creates an empty hash object + constexpr FnvHasher() = default; + + // Hashes a numeric value. + template < + typename T, + typename std::enable_if::value, bool>::type = true> + void Update(T data) { + Update(reinterpret_cast(&data), sizeof(data)); + } + + constexpr void Update(char c) { return Update(&c, 1); } + + // Using the loop instead of "Update(str, strlen(str))" to avoid looping twice + constexpr void Update(const char* str) { + for (const auto* p = str; *p; ++p) + Update(*p); + } + + // Hashes a byte array. + constexpr void Update(const char* data, size_t size) { + for (size_t i = 0; i < size; i++) { + result_ ^= static_cast(data[i]); + // Note: Arithmetic overflow of unsigned integers is well defined in C++ + // standard unlike signed integers. + // https://stackoverflow.com/a/41280273 + result_ *= kFnv1a64Prime; + } + } + + // Allow hashing anything that has `data` and `size` and has the kHashable + // trait (e.g., base::StringView). + template > + constexpr void Update(const T& t) { + if constexpr (std::is_member_function_pointer_v) { + Update(t.data(), t.size()); + } else { + Update(t.data, t.size); + } + } + + constexpr void Update(std::string_view s) { Update(s.data(), s.size()); } + + constexpr uint64_t digest() const { return result_; } + + // Usage: + // uint64_t hashed_value = + // FnvHasher::Combine(33, false, "ABC", 458L, 3u, 'x'); + template + static constexpr uint64_t Combine(Ts&&... args) { + FnvHasher hasher; + hasher.UpdateAll(std::forward(args)...); + return hasher.digest(); + } + + // Creates a hasher with `args` already hashed. + // + // Usage: + // FnvHasher partial = FnvHasher::CreatePartial(33, false, "ABC", 458L); + template + static constexpr FnvHasher CreatePartial(Ts&&... args) { + FnvHasher hasher; + hasher.UpdateAll(std::forward(args)...); + return hasher; + } + + // `hasher.UpdateAll(33, false, "ABC")` is shorthand for: + // `hasher.Update(33); hasher.Update(false); hasher.Update("ABC");` + constexpr void UpdateAll() {} + + template + constexpr void UpdateAll(T&& arg, Ts&&... args) { + Update(arg); + UpdateAll(std::forward(args)...); + } + + private: + static constexpr uint64_t kFnv1a64OffsetBasis = 0xcbf29ce484222325; + static constexpr uint64_t kFnv1a64Prime = 0x100000001b3; + + uint64_t result_ = kFnv1a64OffsetBasis; +}; + +// base::FnvHash uses base::FnvHasher for integer values and falls back to +// std::hash for other types. This is needed as std::hash for integers is just +// the identity function and Perfetto uses open-addressing hash table, which are +// very sensitive to hash quality and are known to degrade in performance +// when using std::hash. +template +struct FnvHash { + // Version for ints, using base::FnvHasher. + template + auto operator()(const U& x) -> + typename std::enable_if::value, size_t>::type + const { + return FnvHasher::Combine(x); + } + + // Version for non-ints, falling back to std::hash. + template + auto operator()(const U& x) -> + typename std::enable_if::value, size_t>::type + const { + return std::hash()(x); + } +}; + +} // namespace perfetto::base + +#endif // INCLUDE_PERFETTO_EXT_BASE_FNV_HASH_H_ +/* + * Copyright (C) 2018 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef INCLUDE_PERFETTO_EXT_BASE_STRING_VIEW_H_ +#define INCLUDE_PERFETTO_EXT_BASE_STRING_VIEW_H_ + +#include + +#include +#include +#include + +// gen_amalgamated expanded: #include "perfetto/base/build_config.h" +// gen_amalgamated expanded: #include "perfetto/base/logging.h" +// gen_amalgamated expanded: #include "perfetto/ext/base/fnv_hash.h" + +namespace perfetto { +namespace base { + +// A string-like object that refers to a non-owned piece of memory. +// Strings are internally NOT null terminated. +class StringView { + public: + // Allow hashing with base::FnvHash. + static constexpr bool kHashable = true; + static constexpr size_t npos = static_cast(-1); + + StringView() : data_(nullptr), size_(0) {} + StringView(const StringView&) = default; + StringView& operator=(const StringView&) = default; + StringView(const char* data, size_t size) : data_(data), size_(size) { + PERFETTO_DCHECK(size == 0 || data != nullptr); + } + + // Allow implicit conversion from any class that has a |data| and |size| field + // and has the kConvertibleToStringView trait (e.g., protozero::ConstChars). + template > + StringView(const T& x) : StringView(x.data, x.size) { + PERFETTO_DCHECK(x.size == 0 || x.data != nullptr); + } + + // Creates a StringView from a null-terminated C string. + // Deliberately not "explicit". + StringView(const char* cstr) : data_(cstr), size_(strlen(cstr)) { + PERFETTO_DCHECK(cstr != nullptr); + } + + StringView(std::string_view str) : data_(str.data()), size_(str.size()) {} + + // This instead has to be explicit, as creating a StringView out of a + // std::string can be subtle. + explicit StringView(const std::string& str) + : data_(str.data()), size_(str.size()) {} + + bool empty() const { return size_ == 0; } + size_t size() const { return size_; } + const char* data() const { return data_; } + const char* begin() const { return data_; } + const char* end() const { return data_ + size_; } + + char at(size_t pos) const { + PERFETTO_DCHECK(pos < size_); + return data_[pos]; + } + + size_t find(char c, size_t start_pos = 0) const { + for (size_t i = start_pos; i < size_; ++i) { + if (data_[i] == c) + return i; + } + return npos; + } + + size_t find(const StringView& str, size_t start_pos = 0) const { + if (start_pos > size()) + return npos; + auto it = std::search(begin() + start_pos, end(), str.begin(), str.end()); + size_t pos = static_cast(it - begin()); + return pos + str.size() <= size() ? pos : npos; + } + + size_t find(const char* str, size_t start_pos = 0) const { + return find(StringView(str), start_pos); + } + + size_t rfind(char c) const { + for (size_t i = size_; i > 0; --i) { + if (data_[i - 1] == c) + return i - 1; + } + return npos; + } + + StringView substr(size_t pos, size_t count = npos) const { + if (pos >= size_) + return StringView("", 0); + size_t rcount = std::min(count, size_ - pos); + return StringView(data_ + pos, rcount); + } + + bool CaseInsensitiveEq(const StringView& other) const { + if (size() != other.size()) + return false; + if (size() == 0) + return true; +#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) + return _strnicmp(data(), other.data(), size()) == 0; +#else + return strncasecmp(data(), other.data(), size()) == 0; +#endif + } + + bool CaseInsensitiveOneOf(const std::vector& others) const { + for (const StringView& other : others) { + if (CaseInsensitiveEq(other)) { + return true; + } + } + return false; + } + + bool StartsWith(const StringView& other) const { + if (other.size() == 0) + return true; + if (size() == 0) + return false; + if (other.size() > size()) + return false; + return memcmp(data(), other.data(), other.size()) == 0; + } + + bool EndsWith(const StringView& other) const { + if (other.size() == 0) + return true; + if (size() == 0) + return false; + if (other.size() > size()) + return false; + size_t off = size() - other.size(); + return memcmp(data() + off, other.data(), other.size()) == 0; + } + + std::string ToStdString() const { + return size_ == 0 ? "" : std::string(data_, size_); + } + + uint64_t Hash() const { + base::FnvHasher hasher; + hasher.Update(data_, size_); + return hasher.digest(); + } + + private: + const char* data_ = nullptr; + size_t size_ = 0; +}; + +inline bool operator==(const StringView& x, const StringView& y) { + if (x.size() != y.size()) + return false; + if (x.size() == 0) + return true; + return memcmp(x.data(), y.data(), x.size()) == 0; +} + +inline bool operator!=(const StringView& x, const StringView& y) { + return !(x == y); +} + +inline bool operator<(const StringView& x, const StringView& y) { + auto size = std::min(x.size(), y.size()); + if (size == 0) + return x.size() < y.size(); + int result = memcmp(x.data(), y.data(), size); + return result < 0 || (result == 0 && x.size() < y.size()); +} + +inline bool operator>=(const StringView& x, const StringView& y) { + return !(x < y); +} + +inline bool operator>(const StringView& x, const StringView& y) { + return y < x; +} + +inline bool operator<=(const StringView& x, const StringView& y) { + return !(y < x); +} + +} // namespace base +} // namespace perfetto + +template <> +struct std::hash<::perfetto::base::StringView> { + size_t operator()(const ::perfetto::base::StringView& sv) const { + return static_cast(sv.Hash()); + } +}; + +#endif // INCLUDE_PERFETTO_EXT_BASE_STRING_VIEW_H_ +/* + * Copyright (C) 2018 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef INCLUDE_PERFETTO_EXT_BASE_STRING_UTILS_H_ +#define INCLUDE_PERFETTO_EXT_BASE_STRING_UTILS_H_ + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +// gen_amalgamated expanded: #include "perfetto/ext/base/string_view.h" + +namespace perfetto { +namespace base { + +inline char Lowercase(char c) { + return ('A' <= c && c <= 'Z') ? static_cast(c - ('A' - 'a')) : c; +} + +inline char Uppercase(char c) { + return ('a' <= c && c <= 'z') ? static_cast(c + ('A' - 'a')) : c; +} + +inline std::optional CStringToUInt32(const char* s, int base = 10) { + char* endptr = nullptr; + auto value = static_cast(strtoul(s, &endptr, base)); + return (*s && !*endptr) ? std::make_optional(value) : std::nullopt; +} + +inline std::optional CStringToInt32(const char* s, int base = 10) { + char* endptr = nullptr; + auto value = static_cast(strtol(s, &endptr, base)); + return (*s && !*endptr) ? std::make_optional(value) : std::nullopt; +} + +// Note: it saturates to 7fffffffffffffff if parsing a hex number >= 0x8000... +inline std::optional CStringToInt64(const char* s, int base = 10) { + char* endptr = nullptr; + auto value = static_cast(strtoll(s, &endptr, base)); + return (*s && !*endptr) ? std::make_optional(value) : std::nullopt; +} + +inline std::optional CStringToUInt64(const char* s, int base = 10) { + char* endptr = nullptr; + auto value = static_cast(strtoull(s, &endptr, base)); + return (*s && !*endptr) ? std::make_optional(value) : std::nullopt; +} + +double StrToD(const char* nptr, char** endptr); + +inline std::optional CStringToDouble(const char* s) { + char* endptr = nullptr; + double value = StrToD(s, &endptr); + std::optional result(std::nullopt); + if (*s != '\0' && *endptr == '\0') + result = value; + return result; +} + +inline std::optional StringToUInt32(const std::string& s, + int base = 10) { + return CStringToUInt32(s.c_str(), base); +} + +inline std::optional StringToInt32(const std::string& s, + int base = 10) { + return CStringToInt32(s.c_str(), base); +} + +inline std::optional StringToUInt64(const std::string& s, + int base = 10) { + return CStringToUInt64(s.c_str(), base); +} + +inline std::optional StringToInt64(const std::string& s, + int base = 10) { + return CStringToInt64(s.c_str(), base); +} + +inline std::optional StringToDouble(const std::string& s) { + return CStringToDouble(s.c_str()); +} + +template +inline std::optional StringViewToNumber(const base::StringView& sv, + int base = 10) { + // std::from_chars() does not regonize the leading '+' character and only + // recognizes '-' so remove the '+' if it exists to avoid errors and match + // the behavior of the other string conversion utilities above. + size_t start_offset = !sv.empty() && sv.at(0) == '+' ? 1 : 0; + T value; + auto result = + std::from_chars(sv.begin() + start_offset, sv.end(), value, base); + if (result.ec == std::errc() && result.ptr == sv.end()) { + return value; + } else { + return std::nullopt; + } +} + +inline std::optional StringViewToUInt32(const base::StringView& sv, + int base = 10) { + // std::from_chars() does not recognize the leading '-' character for + // unsigned conversions, but strtol does. To Mimic the behavior of strtol, + // attempt a signed converion if we see a leading '-', and then cast the + // result back to unsigned. + if (sv.size() > 0 && sv.at(0) == '-') { + return static_cast >( + StringViewToNumber(sv, base)); + } else { + return StringViewToNumber(sv, base); + } +} + +inline std::optional StringViewToInt32(const base::StringView& sv, + int base = 10) { + return StringViewToNumber(sv, base); +} + +inline std::optional StringViewToUInt64(const base::StringView& sv, + int base = 10) { + // std::from_chars() does not recognize the leading '-' character for + // unsigned conversions, but strtol does. To Mimic the behavior of strtol, + // attempt a signed converion if we see a leading '-', and then cast the + // result back to unsigned. + if (sv.size() > 0 && sv.at(0) == '-') { + return static_cast >( + StringViewToNumber(sv, base)); + } else { + return StringViewToNumber(sv, base); + } +} + +inline std::optional StringViewToInt64(const base::StringView& sv, + int base = 10) { + return StringViewToNumber(sv, base); +} + +// TODO: As of Clang 19.0 std::from_chars is unimplemented for type double +// despite being part of C++17 standard, and already being supported by GCC and +// MSVC. Enable this once we have double support in Clang. +// inline std::optional StringViewToDouble(const base::StringView& sv) { +// return StringViewToNumber(sv); +// } + +bool StartsWith(const std::string& str, const std::string& prefix); +bool EndsWith(const std::string& str, const std::string& suffix); +bool StartsWithAny(const std::string& str, + const std::vector& prefixes); +bool Contains(const std::string& haystack, const std::string& needle); +bool Contains(const std::string& haystack, char needle); +bool Contains(const std::vector& haystack, + const std::string& needle); +size_t Find(const StringView& needle, const StringView& haystack); +bool CaseInsensitiveEqual(const std::string& first, const std::string& second); +std::string Join(const std::vector& parts, + const std::string& delim); +std::vector SplitString(const std::string& text, + const std::string& delimiter); +std::string StripPrefix(const std::string& str, const std::string& prefix); +std::string StripSuffix(const std::string& str, const std::string& suffix); +std::string TrimWhitespace(const std::string& str); +std::string ToLower(const std::string& str); +std::string ToUpper(const std::string& str); +std::string StripChars(const std::string& str, + const std::string& chars, + char replacement); +std::string ToHex(const char* data, size_t size); +inline std::string ToHex(const std::string& s) { + return ToHex(s.c_str(), s.size()); +} +std::string IntToHexString(uint32_t number); +std::string Uint64ToHexString(uint64_t number); +std::string Uint64ToHexStringNoPrefix(uint64_t number); +std::string ReplaceAll(std::string str, + const std::string& to_replace, + const std::string& replacement); + +// Checks if all characters in the input string view `str` are ASCII. +// +// If so, the function returns true and `output` is not modified. +// If `str` contains non-ASCII characters, the function returns false, +// removes invalid UTF-8 characters from `str`, and stores the result in +// `output`. +bool CheckAsciiAndRemoveInvalidUTF8(base::StringView str, std::string& output); + +#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) +bool WideToUTF8(const std::wstring& source, std::string& output); +bool UTF8ToWide(const std::string& source, std::wstring& output); +#endif // PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) + +// A BSD-style strlcpy without the return value. +// Copies at most |dst_size|-1 characters. Unlike strncpy, it always \0 +// terminates |dst|, as long as |dst_size| is not 0. +// Unlike strncpy and like strlcpy it does not zero-pad the rest of |dst|. +// Returns nothing. The BSD strlcpy returns the size of |src|, which might +// be > |dst_size|. Anecdotal experience suggests people assume the return value +// is the number of bytes written in |dst|. That assumption can lead to +// dangerous bugs. +// In order to avoid being subtly uncompliant with strlcpy AND avoid misuse, +// the choice here is to return nothing. +inline void StringCopy(char* dst, const char* src, size_t dst_size) { + for (size_t i = 0; i < dst_size; ++i) { + if ((dst[i] = src[i]) == '\0') { + return; // We hit and copied the null terminator. + } + } + + // We were left off at dst_size. We over copied 1 byte. Null terminate. + if (PERFETTO_LIKELY(dst_size > 0)) + dst[dst_size - 1] = 0; +} + +// Like snprintf() but returns the number of chars *actually* written (without +// counting the null terminator) NOT "the number of chars which would have been +// written to the final string if enough space had been available". +// This should be used in almost all cases when the caller uses the return value +// of snprintf(). If the return value is not used, there is no benefit in using +// this wrapper, as this just calls snprintf() and mangles the return value. +// It always null-terminates |dst| (even in case of errors), unless +// |dst_size| == 0. +// Examples: +// SprintfTrunc(x, 4, "123whatever"): returns 3 and writes "123\0". +// SprintfTrunc(x, 4, "123"): returns 3 and writes "123\0". +// SprintfTrunc(x, 3, "123"): returns 2 and writes "12\0". +// SprintfTrunc(x, 2, "123"): returns 1 and writes "1\0". +// SprintfTrunc(x, 1, "123"): returns 0 and writes "\0". +// SprintfTrunc(x, 0, "123"): returns 0 and writes nothing. +// NOTE: This means that the caller has no way to tell when truncation happens +// vs the edge case of *just* fitting in the buffer. +size_t SprintfTrunc(char* dst, size_t dst_size, const char* fmt, ...) + PERFETTO_PRINTF_FORMAT(3, 4); + +// Line number starts from 1 +struct LineWithOffset { + base::StringView line; + uint32_t line_offset; + uint32_t line_num; +}; + +// For given string and offset Pfinds a line with character for +// which offset points, what number is this line (starts from 1), and the offset +// inside this line. returns std::nullopt if the offset points to +// line break character or exceeds string length. +std::optional FindLineWithOffset(base::StringView str, + uint32_t offset); + +// A helper class to facilitate construction and usage of write-once stack +// strings. +// Example usage: +// StackString<32> x("format %d %s", 42, string_arg); +// TakeString(x.c_str() | x.string_view() | x.ToStdString()); +// Rather than char x[32] + sprintf. +// Advantages: +// - Avoids useless zero-fills caused by people doing `char buf[32] {}` (mainly +// by fearing unknown snprintf failure modes). +// - Makes the code more robust in case of snprintf truncations (len() and +// string_view() will return the truncated length, unlike snprintf). +template +class StackString { + public: + explicit PERFETTO_PRINTF_FORMAT(/* 1=this */ 2, 3) + StackString(const char* fmt, ...) { + buf_[0] = '\0'; + va_list args; + va_start(args, fmt); + int res = vsnprintf(buf_, sizeof(buf_), fmt, args); + va_end(args); + buf_[sizeof(buf_) - 1] = '\0'; + len_ = res < 0 ? 0 : std::min(static_cast(res), sizeof(buf_) - 1); + } + + StringView string_view() const { return StringView(buf_, len_); } + std::string ToStdString() const { return std::string(buf_, len_); } + const char* c_str() const { return buf_; } + size_t len() const { return len_; } + char* mutable_data() { return buf_; } + + private: + char buf_[N]; + size_t len_ = 0; // Does not include the \0. +}; + +} // namespace base +} // namespace perfetto + +#endif // INCLUDE_PERFETTO_EXT_BASE_STRING_UTILS_H_ +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// gen_amalgamated expanded: #include "perfetto/ext/base/android_utils.h" + +// gen_amalgamated expanded: #include "perfetto/base/build_config.h" + +#include + +#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) +#include +#endif + +// gen_amalgamated expanded: #include "perfetto/base/compiler.h" +// gen_amalgamated expanded: #include "perfetto/base/logging.h" +// gen_amalgamated expanded: #include "perfetto/base/time.h" +// gen_amalgamated expanded: #include "perfetto/ext/base/string_utils.h" + +#if !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) && \ + !PERFETTO_BUILDFLAG(PERFETTO_OS_NACL) && \ + !PERFETTO_BUILDFLAG(PERFETTO_OS_WASM) +#include +#include +#endif + +namespace perfetto { +namespace base { + +#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) + +std::string GetAndroidProp(const char* name) { + std::string ret; +#if __ANDROID_API__ >= 26 + const prop_info* pi = __system_property_find(name); + if (!pi) { + return ret; + } + __system_property_read_callback( + pi, + [](void* dst_void, const char*, const char* value, uint32_t) { + std::string& dst = *static_cast(dst_void); + dst = value; + }, + &ret); +#else // __ANDROID_API__ < 26 + char value_buf[PROP_VALUE_MAX]; + int len = __system_property_get(name, value_buf); + if (len > 0 && static_cast(len) < sizeof(value_buf)) { + ret = std::string(value_buf, static_cast(len)); + } +#endif + return ret; +} + +#endif // PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) + +Utsname GetUtsname() { + Utsname utsname_info; +#if !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) && \ + !PERFETTO_BUILDFLAG(PERFETTO_OS_NACL) && \ + !PERFETTO_BUILDFLAG(PERFETTO_OS_WASM) + struct utsname uname_info; + if (uname(&uname_info) == 0) { + utsname_info.sysname = uname_info.sysname; + utsname_info.version = uname_info.version; + utsname_info.machine = uname_info.machine; + utsname_info.release = uname_info.release; + } else { + PERFETTO_ELOG("Unable to read Utsname information"); + } +#endif // !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) + return utsname_info; +} + +SystemInfo GetSystemInfo() { + SystemInfo info; + + info.timezone_off_mins = GetTimezoneOffsetMins(); + +#if !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) && \ + !PERFETTO_BUILDFLAG(PERFETTO_OS_NACL) && \ + !PERFETTO_BUILDFLAG(PERFETTO_OS_WASM) + info.utsname_info = GetUtsname(); + info.page_size = static_cast(sysconf(_SC_PAGESIZE)); + info.num_cpus = static_cast(sysconf(_SC_NPROCESSORS_CONF)); +#endif // !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) +#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) + info.android_build_fingerprint = GetAndroidProp("ro.build.fingerprint"); + if (info.android_build_fingerprint.empty()) { + PERFETTO_ELOG("Unable to read ro.build.fingerprint"); + } + + info.android_device_manufacturer = GetAndroidProp("ro.product.manufacturer"); + if (info.android_device_manufacturer.empty()) { + PERFETTO_ELOG("Unable to read ro.product.manufacturer"); + } + + std::string sdk_str_value = GetAndroidProp("ro.build.version.sdk"); + info.android_sdk_version = StringToUInt64(sdk_str_value); + if (!info.android_sdk_version.has_value()) { + PERFETTO_ELOG("Unable to read ro.build.version.sdk"); + } + + info.android_soc_model = GetAndroidProp("ro.soc.model"); + if (info.android_soc_model.empty()) { + PERFETTO_ELOG("Unable to read ro.soc.model"); + } + + // guest_soc model is not always present + info.android_guest_soc_model = GetAndroidProp("ro.boot.guest_soc.model"); + + info.android_hardware_revision = GetAndroidProp("ro.boot.hardware.revision"); + if (info.android_hardware_revision.empty()) { + PERFETTO_ELOG("Unable to read ro.boot.hardware.revision"); + } + + info.android_storage_model = GetAndroidProp("ro.boot.hardware.ufs"); + if (info.android_storage_model.empty()) { + PERFETTO_ELOG("Unable to read ro.boot.hardware.ufs"); + } + + info.android_ram_model = GetAndroidProp("ro.boot.hardware.ddr"); + if (info.android_ram_model.empty()) { + PERFETTO_ELOG("Unable to read ro.boot.hardware.ddr"); + } + + info.android_serial_console = GetAndroidProp("init.svc.console"); + if (info.android_serial_console.empty()) { + PERFETTO_ELOG("Unable to read init.svc.console"); + } +#endif // PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) + + return info; +} + +std::string GetPerfettoMachineName() { + const char* env_name = getenv("PERFETTO_MACHINE_NAME"); + if (env_name) { + return env_name; + } +#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) + std::string name = base::GetAndroidProp("traced.machine_name"); + if (name.empty()) { + name = GetUtsname().sysname; + } + return name; +#else + return GetUtsname().sysname; +#endif +} + +} // namespace base +} // namespace perfetto +// gen_amalgamated begin source: src/base/base64.cc +// gen_amalgamated begin header: include/perfetto/ext/base/base64.h +// gen_amalgamated begin header: include/perfetto/ext/base/utils.h +// gen_amalgamated begin header: include/perfetto/ext/base/sys_types.h +/* + * Copyright (C) 2022 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef INCLUDE_PERFETTO_EXT_BASE_SYS_TYPES_H_ +#define INCLUDE_PERFETTO_EXT_BASE_SYS_TYPES_H_ + +// This headers deals with sys types commonly used in the codebase that are +// missing on Windows. + +#include // IWYU pragma: export +#include + +// gen_amalgamated expanded: #include "perfetto/base/build_config.h" + +#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) + +#if !PERFETTO_BUILDFLAG(PERFETTO_COMPILER_GCC) +// MinGW has these. clang-cl and MSVC, which use just the Windows SDK, don't. +using uid_t = int; +using pid_t = int; +#endif // !GCC + +#if defined(_WIN64) +using ssize_t = int64_t; +#else +using ssize_t = long; +#endif // _WIN64 + +#endif // OS_WIN + +#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) +// From libcutils' android_filesystem_config.h +#ifndef AID_ROOT +#define AID_ROOT 0 +#endif +#ifndef AID_STATSD +#define AID_STATSD 1066 +#endif +#ifndef AID_SHELL +#define AID_SHELL 2000 +#endif +#endif + +namespace perfetto { +namespace base { + +// The machine ID used in the tracing core. +using MachineID = uint32_t; +// The default value reserved for the host trace. +constexpr MachineID kDefaultMachineID = 0; + +constexpr uid_t kInvalidUid = static_cast(-1); +constexpr pid_t kInvalidPid = static_cast(-1); + +} // namespace base +} // namespace perfetto + +#endif // INCLUDE_PERFETTO_EXT_BASE_SYS_TYPES_H_ +/* + * Copyright (C) 2017 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef INCLUDE_PERFETTO_EXT_BASE_UTILS_H_ +#define INCLUDE_PERFETTO_EXT_BASE_UTILS_H_ + +#include +#include +#include +#include + +#include +#include +#include +#include + +// gen_amalgamated expanded: #include "perfetto/base/build_config.h" +// gen_amalgamated expanded: #include "perfetto/base/compiler.h" +// gen_amalgamated expanded: #include "perfetto/ext/base/sys_types.h" + +#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) +// Even if Windows has errno.h, the all syscall-restart behavior does not apply. +// Trying to handle EINTR can cause more harm than good if errno is left stale. +// Chromium does the same. +#define PERFETTO_EINTR(x) (x) +#else +#define PERFETTO_EINTR(x) \ + ([&] { \ + decltype(x) eintr_wrapper_result; \ + do { \ + eintr_wrapper_result = (x); \ + } while (eintr_wrapper_result == -1 && errno == EINTR); \ + return eintr_wrapper_result; \ + }()) +#endif + +namespace perfetto { +namespace base { + +namespace internal { +extern std::atomic g_cached_page_size; +uint32_t GetSysPageSizeSlowpath(); +} // namespace internal + +// Returns the system's page size. Use this when dealing with mmap, madvise and +// similar mm-related syscalls. +// This function might be called in hot paths. Avoid calling getpagesize() all +// the times, in many implementations getpagesize() calls sysconf() which is +// not cheap. +inline uint32_t GetSysPageSize() { + const uint32_t page_size = + internal::g_cached_page_size.load(std::memory_order_relaxed); + return page_size != 0 ? page_size : internal::GetSysPageSizeSlowpath(); +} + +template +constexpr size_t ArraySize(const T (&)[TSize]) { + return TSize; +} + +// Function object which invokes 'free' on its parameter, which must be +// a pointer. Can be used to store malloc-allocated pointers in std::unique_ptr: +// +// std::unique_ptr foo_ptr( +// static_cast(malloc(sizeof(int)))); +struct FreeDeleter { + inline void operator()(void* ptr) const { free(ptr); } +}; + +template +constexpr T AssumeLittleEndian(T value) { +#if !PERFETTO_IS_LITTLE_ENDIAN() + static_assert(false, "Unimplemented on big-endian archs"); +#endif + return value; +} + +// Round up |size| to a multiple of |alignment| (must be a power of two). +inline constexpr size_t AlignUp(size_t size, size_t alignment) { + return (size + alignment - 1) & ~(alignment - 1); +} + +// TODO(primiano): clean this up and move all existing usages to the constexpr +// version above. +template +constexpr size_t AlignUp(size_t size) { + static_assert((alignment & (alignment - 1)) == 0, "alignment must be a pow2"); + return AlignUp(size, alignment); +} + +inline bool IsAgain(int err) { + return err == EAGAIN || err == EWOULDBLOCK; +} + +// setenv(2)-equivalent. Deals with Windows vs Posix discrepancies. +void SetEnv(const std::string& key, const std::string& value); + +// unsetenv(2)-equivalent. Deals with Windows vs Posix discrepancies. +void UnsetEnv(const std::string& key); + +// Calls mallopt(M_PURGE, 0) on Android. Does nothing on other platforms. +// This forces the allocator to release freed memory. This is used to work +// around various Scudo inefficiencies. See b/170217718. +void MaybeReleaseAllocatorMemToOS(); + +// geteuid() on POSIX OSes, returns 0 on Windows (See comment in utils.cc). +uid_t GetCurrentUserId(); + +// Forks the process. +// Parent: prints the PID of the child, calls |parent_cb| and exits from the +// process with its return value. +// Child: redirects stdio onto /dev/null, chdirs into / and returns. +void Daemonize(std::function parent_cb); + +// Returns the path of the current executable, e.g. /foo/bar/exe. +std::string GetCurExecutablePath(); + +// Returns the directory where the current executable lives in, e.g. /foo/bar. +// This is independent of cwd(). +std::string GetCurExecutableDir(); + +// Memory returned by AlignedAlloc() must be freed via AlignedFree() not just +// free. It makes a difference on Windows where _aligned_malloc() and +// _aligned_free() must be paired. +// Prefer using the AlignedAllocTyped() below which takes care of the pairing. +void* AlignedAlloc(size_t alignment, size_t size); +void AlignedFree(void*); + +// Detects Sync-mode MTE (currently being tested in some Android builds). +// This is known to use extra memory for the stack history buffer. +bool IsSyncMemoryTaggingEnabled(); + +// A RAII version of the above, which takes care of pairing Aligned{Alloc,Free}. +template +struct AlignedDeleter { + inline void operator()(T* ptr) const { AlignedFree(ptr); } +}; + +// The remove_extent here and below is to allow defining unique_ptr. +// As per https://en.cppreference.com/w/cpp/memory/unique_ptr the Deleter takes +// always a T*, not a T[]*. +template +using AlignedUniquePtr = + std::unique_ptr::type>>; + +template +AlignedUniquePtr AlignedAllocTyped(size_t n_membs) { + using TU = typename std::remove_extent::type; + return AlignedUniquePtr( + static_cast(AlignedAlloc(alignof(TU), sizeof(TU) * n_membs))); +} + +// A RAII wrapper to invoke a function when leaving a function/scope. +template +class OnScopeExitWrapper { + public: + explicit OnScopeExitWrapper(Func f) : f_(std::move(f)), active_(true) {} + OnScopeExitWrapper(OnScopeExitWrapper&& other) noexcept + : f_(std::move(other.f_)), active_(other.active_) { + other.active_ = false; + } + ~OnScopeExitWrapper() { + if (active_) + f_(); + } + + private: + Func f_; + bool active_; +}; + +template +PERFETTO_WARN_UNUSED_RESULT OnScopeExitWrapper OnScopeExit(Func f) { + return OnScopeExitWrapper(std::move(f)); +} + +// Returns a xxd-style hex dump (hex + ascii chars) of the input data. +std::string HexDump(const void* data, size_t len, size_t bytes_per_line = 16); +inline std::string HexDump(const std::string& data, + size_t bytes_per_line = 16) { + return HexDump(data.data(), data.size(), bytes_per_line); +} + +} // namespace base +} // namespace perfetto + +#endif // INCLUDE_PERFETTO_EXT_BASE_UTILS_H_ +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef INCLUDE_PERFETTO_EXT_BASE_BASE64_H_ +#define INCLUDE_PERFETTO_EXT_BASE_BASE64_H_ + +#include +#include + +// gen_amalgamated expanded: #include "perfetto/ext/base/string_view.h" +// gen_amalgamated expanded: #include "perfetto/ext/base/utils.h" // For ssize_t. + +namespace perfetto { +namespace base { + +// Returns the length of the destination string (included '=' padding). +// Does NOT include the size of the string null terminator. +inline size_t Base64EncSize(size_t src_size) { + return (src_size + 2) / 3 * 4; +} + +// Returns the upper bound on the length of the destination buffer. +// The actual decoded length might be <= the number returned here. +inline size_t Base64DecSize(size_t src_size) { + return (src_size + 3) / 4 * 3; +} + +// Does NOT null-terminate |dst|. +ssize_t Base64Encode(const void* src, + size_t src_size, + char* dst, + size_t dst_size); + +std::string Base64Encode(const void* src, size_t src_size); + +inline std::string Base64Encode(StringView sv) { + return Base64Encode(sv.data(), sv.size()); +} + +// Returns -1 in case of failure. +ssize_t Base64Decode(const char* src, + size_t src_size, + uint8_t* dst, + size_t dst_size); + +std::optional Base64Decode(const char* src, size_t src_size); + +inline std::optional Base64Decode(StringView sv) { + return Base64Decode(sv.data(), sv.size()); +} + +} // namespace base +} // namespace perfetto + +#endif // INCLUDE_PERFETTO_EXT_BASE_BASE64_H_ +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// gen_amalgamated expanded: #include "perfetto/ext/base/base64.h" + +namespace perfetto { +namespace base { + +namespace { + +constexpr char kPadding = '='; + +constexpr char kEncTable[] = + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; +static_assert(sizeof(kEncTable) == (1u << 6) + sizeof('\0'), "Bad table size"); + +// Maps an ASCII character to its 6-bit value. It only contains translations +// from '+' to 'z'. Supports the standard (+/) and URL-safe (-_) alphabets. +constexpr uint8_t kX = 0xff; // Value used for invalid characters +constexpr uint8_t kDecTable[] = { + 62, kX, 62, kX, 63, 52, 53, 54, 55, 56, // 00 - 09 + 57, 58, 59, 60, 61, kX, kX, kX, 0, kX, // 10 - 19 + kX, kX, 0, 1, 2, 3, 4, 5, 6, 7, // 20 - 29 + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, // 30 - 39 + 18, 19, 20, 21, 22, 23, 24, 25, kX, kX, // 40 - 49 + kX, kX, 63, kX, 26, 27, 28, 29, 30, 31, // 50 - 59 + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, // 60 - 69 + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, // 70 - 79 +}; +constexpr char kMinDecChar = '+'; +constexpr char kMaxDecChar = 'z'; +static_assert(kMaxDecChar - kMinDecChar <= sizeof(kDecTable), "Bad table size"); + +inline uint8_t DecodeChar(char c) { + if (c < kMinDecChar || c > kMaxDecChar) + return kX; + return kDecTable[c - kMinDecChar]; +} + +} // namespace + +ssize_t Base64Encode(const void* src, + size_t src_size, + char* dst, + size_t dst_size) { + const size_t padded_dst_size = Base64EncSize(src_size); + if (dst_size < padded_dst_size) + return -1; // Not enough space in output. + + const uint8_t* rd = static_cast(src); + const uint8_t* const end = rd + src_size; + size_t wr_size = 0; + while (rd < end) { + uint8_t s[3]{}; + s[0] = *(rd++); + dst[wr_size++] = kEncTable[s[0] >> 2]; + + uint8_t carry0 = static_cast((s[0] & 0x03) << 4); + if (PERFETTO_LIKELY(rd < end)) { + s[1] = *(rd++); + dst[wr_size++] = kEncTable[carry0 | (s[1] >> 4)]; + } else { + dst[wr_size++] = kEncTable[carry0]; + dst[wr_size++] = kPadding; + dst[wr_size++] = kPadding; + break; + } + + uint8_t carry1 = static_cast((s[1] & 0x0f) << 2); + if (PERFETTO_LIKELY(rd < end)) { + s[2] = *(rd++); + dst[wr_size++] = kEncTable[carry1 | (s[2] >> 6)]; + } else { + dst[wr_size++] = kEncTable[carry1]; + dst[wr_size++] = kPadding; + break; + } + + dst[wr_size++] = kEncTable[s[2] & 0x3f]; + } + PERFETTO_DCHECK(wr_size == padded_dst_size); + return static_cast(padded_dst_size); +} + +std::string Base64Encode(const void* src, size_t src_size) { + std::string dst; + dst.resize(Base64EncSize(src_size)); + auto res = Base64Encode(src, src_size, &dst[0], dst.size()); + PERFETTO_CHECK(res == static_cast(dst.size())); + return dst; +} + +ssize_t Base64Decode(const char* src, + size_t src_size, + uint8_t* dst, + size_t dst_size) { + const size_t min_dst_size = Base64DecSize(src_size); + if (dst_size < min_dst_size) + return -1; + + const char* rd = src; + const char* const end = src + src_size; + size_t wr_size = 0; + + char s[4]{}; + while (rd < end) { + uint8_t d[4]; + for (uint32_t j = 0; j < 4; j++) { + // Padding is only feasible for the last 2 chars of each group of 4. + s[j] = rd < end ? *(rd++) : (j < 2 ? '\0' : kPadding); + d[j] = DecodeChar(s[j]); + if (d[j] == kX) + return -1; // Invalid input char. + } + dst[wr_size] = static_cast((d[0] << 2) | (d[1] >> 4)); + dst[wr_size + 1] = static_cast((d[1] << 4) | (d[2] >> 2)); + dst[wr_size + 2] = static_cast((d[2] << 6) | (d[3])); + wr_size += 3; + } + + PERFETTO_CHECK(wr_size <= dst_size); + wr_size -= (s[3] == kPadding ? 1 : 0) + (s[2] == kPadding ? 1 : 0); + return static_cast(wr_size); +} + +std::optional Base64Decode(const char* src, size_t src_size) { + std::string dst; + dst.resize(Base64DecSize(src_size)); + auto res = Base64Decode(src, src_size, reinterpret_cast(&dst[0]), + dst.size()); + if (res < 0) + return std::nullopt; // Decoding error. + + PERFETTO_CHECK(res <= static_cast(dst.size())); + dst.resize(static_cast(res)); + return std::make_optional(dst); +} + +} // namespace base +} // namespace perfetto +// gen_amalgamated begin source: src/base/crash_keys.cc +// gen_amalgamated begin header: include/perfetto/ext/base/crash_keys.h +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef INCLUDE_PERFETTO_EXT_BASE_CRASH_KEYS_H_ +#define INCLUDE_PERFETTO_EXT_BASE_CRASH_KEYS_H_ + +#include +#include + +#include +#include + +// gen_amalgamated expanded: #include "perfetto/base/compiler.h" +// gen_amalgamated expanded: #include "perfetto/ext/base/string_view.h" + +// Crash keys are very simple global variables with static-storage that +// are reported on crash time for managed crashes (CHECK/FATAL/Watchdog). +// - Translation units can define a CrashKey and register it at some point +// during initialization. +// - CrashKey instances must be long-lived. They should really be just global +// static variable in the anonymous namespace. +// Example: +// subsystem_1.cc +// CrashKey g_client_id("ipc_client_id"); +// ... +// OnIpcReceived(client_id) { +// g_client_id.Set(client_id); +// ... // Process the IPC +// g_client_id.Clear(); +// } +// Or equivalently: +// OnIpcReceived(client_id) { +// auto scoped_key = g_client_id.SetScoped(client_id); +// ... // Process the IPC +// } +// +// If a crash happens while processing the IPC, the crash report will +// have a line "ipc_client_id: 42". +// +// Thread safety considerations: +// CrashKeys can be registered and set/cleared from any thread. +// There is no compelling use-case to have full acquire/release consistency when +// setting a key. This means that if a thread crashes immediately after a +// crash key has been set on another thread, the value printed on the crash +// report could be incomplete. The code guarantees defined behavior and does +// not rely on null-terminated string (in the worst case 32 bytes of random +// garbage will be printed out). + +// The tests live in logging_unittest.cc. + +namespace perfetto { +namespace base { + +constexpr size_t kCrashKeyMaxStrSize = 32; + +// CrashKey instances must be long lived +class CrashKey { + public: + class ScopedClear { + public: + explicit ScopedClear(CrashKey* k) : key_(k) {} + ~ScopedClear() { + if (key_) + key_->Clear(); + } + ScopedClear(const ScopedClear&) = delete; + ScopedClear& operator=(const ScopedClear&) = delete; + ScopedClear& operator=(ScopedClear&&) = delete; + ScopedClear(ScopedClear&& other) noexcept : key_(other.key_) { + other.key_ = nullptr; + } + + private: + CrashKey* key_; + }; + + // constexpr so it can be used in the anon namespace without requiring a + // global constructor. + // |name| must be a long-lived string. + constexpr explicit CrashKey(const char* name) + : registered_{}, type_(Type::kUnset), name_(name), str_value_{} {} + CrashKey(const CrashKey&) = delete; + CrashKey& operator=(const CrashKey&) = delete; + CrashKey(CrashKey&&) = delete; + CrashKey& operator=(CrashKey&&) = delete; + + enum class Type : uint8_t { kUnset = 0, kInt, kStr }; + + void Clear() { + int_value_.store(0, std::memory_order_relaxed); + type_.store(Type::kUnset, std::memory_order_relaxed); + } + + void Set(int64_t value) { + int_value_.store(value, std::memory_order_relaxed); + type_.store(Type::kInt, std::memory_order_relaxed); + if (PERFETTO_UNLIKELY(!registered_.load(std::memory_order_relaxed))) + Register(); + } + + void Set(StringView sv) { + size_t len = std::min(sv.size(), sizeof(str_value_) - 1); + for (size_t i = 0; i < len; ++i) + str_value_[i].store(sv.data()[i], std::memory_order_relaxed); + str_value_[len].store('\0', std::memory_order_relaxed); + type_.store(Type::kStr, std::memory_order_relaxed); + if (PERFETTO_UNLIKELY(!registered_.load(std::memory_order_relaxed))) + Register(); + } + + ScopedClear SetScoped(int64_t value) PERFETTO_WARN_UNUSED_RESULT { + Set(value); + return ScopedClear(this); + } + + ScopedClear SetScoped(StringView sv) PERFETTO_WARN_UNUSED_RESULT { + Set(sv); + return ScopedClear(this); + } + + void Register(); + + int64_t int_value() const { + return int_value_.load(std::memory_order_relaxed); + } + size_t ToString(char* dst, size_t len); + + private: + std::atomic registered_; + std::atomic type_; + const char* const name_; + union { + std::atomic str_value_[kCrashKeyMaxStrSize]; + std::atomic int_value_; + }; +}; + +// Fills |dst| with a string containing one line for each crash key +// (excluding the unset ones). +// Returns number of chars written, without counting the NUL terminator. +// This is used in logging.cc when emitting the crash report abort message. +size_t SerializeCrashKeys(char* dst, size_t len); + +void UnregisterAllCrashKeysForTesting(); + +} // namespace base +} // namespace perfetto + +#endif // INCLUDE_PERFETTO_EXT_BASE_CRASH_KEYS_H_ +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// gen_amalgamated expanded: #include "perfetto/ext/base/crash_keys.h" + +#include + +#include +#include + +// gen_amalgamated expanded: #include "perfetto/ext/base/string_utils.h" + +namespace perfetto { +namespace base { + +namespace { + +constexpr size_t kMaxKeys = 32; + +std::atomic g_keys[kMaxKeys]{}; +std::atomic g_num_keys{}; +} // namespace + +void CrashKey::Register() { + // If doesn't matter if we fail below. If there are no slots left, don't + // keep trying re-registering on every Set(), the outcome won't change. + + // If two threads raced on the Register(), avoid registering the key twice. + if (registered_.exchange(true)) + return; + + uint32_t slot = g_num_keys.fetch_add(1); + if (slot >= kMaxKeys) { + PERFETTO_LOG("Too many crash keys registered"); + return; + } + g_keys[slot].store(this); +} + +// Returns the number of chars written, without counting the \0. +size_t CrashKey::ToString(char* dst, size_t len) { + if (len > 0) + *dst = '\0'; + switch (type_.load(std::memory_order_relaxed)) { + case Type::kUnset: + break; + case Type::kInt: + return SprintfTrunc(dst, len, "%s: %" PRId64 "\n", name_, + int_value_.load(std::memory_order_relaxed)); + case Type::kStr: + char buf[sizeof(str_value_)]; + for (size_t i = 0; i < sizeof(str_value_); i++) + buf[i] = str_value_[i].load(std::memory_order_relaxed); + + // Don't assume |str_value_| is properly null-terminated. + return SprintfTrunc(dst, len, "%s: %.*s\n", name_, int(sizeof(buf)), buf); + } + return 0; +} + +void UnregisterAllCrashKeysForTesting() { + g_num_keys.store(0); + for (auto& key : g_keys) + key.store(nullptr); +} + +size_t SerializeCrashKeys(char* dst, size_t len) { + size_t written = 0; + uint32_t num_keys = g_num_keys.load(); + if (len > 0) + *dst = '\0'; + for (uint32_t i = 0; i < num_keys && written < len; i++) { + CrashKey* key = g_keys[i].load(); + if (!key) + continue; // Can happen if we hit this between the add and the store. + written += key->ToString(dst + written, len - written); + } + PERFETTO_DCHECK(written <= len); + PERFETTO_DCHECK(len == 0 || dst[written] == '\0'); + return written; +} + +} // namespace base +} // namespace perfetto +// gen_amalgamated begin source: src/base/ctrl_c_handler.cc +// gen_amalgamated begin header: include/perfetto/ext/base/ctrl_c_handler.h +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef INCLUDE_PERFETTO_EXT_BASE_CTRL_C_HANDLER_H_ +#define INCLUDE_PERFETTO_EXT_BASE_CTRL_C_HANDLER_H_ + +namespace perfetto { +namespace base { + +// On Linux/Android/Mac: installs SIGINT + SIGTERM signal handlers. +// On Windows: installs a SetConsoleCtrlHandler() handler. +// The passed handler must be async safe. +using CtrlCHandlerFunction = void (*)(); +void InstallCtrlCHandler(CtrlCHandlerFunction); + +} // namespace base +} // namespace perfetto + +#endif // INCLUDE_PERFETTO_EXT_BASE_CTRL_C_HANDLER_H_ +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// gen_amalgamated expanded: #include "perfetto/ext/base/ctrl_c_handler.h" + +// gen_amalgamated expanded: #include "perfetto/base/build_config.h" +// gen_amalgamated expanded: #include "perfetto/base/compiler.h" +// gen_amalgamated expanded: #include "perfetto/base/logging.h" + +#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) +#include + +#include +#else +#include +#include +#endif + +namespace perfetto { +namespace base { + +namespace { +CtrlCHandlerFunction g_handler = nullptr; +} + +void InstallCtrlCHandler(CtrlCHandlerFunction handler) { + PERFETTO_CHECK(g_handler == nullptr); + g_handler = handler; + +#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) + auto trampoline = [](DWORD type) -> int { + if (type == CTRL_C_EVENT) { + g_handler(); + return true; + } + return false; + }; + ::SetConsoleCtrlHandler(trampoline, true); +#elif PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \ + PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) || \ + PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE) + // Setup signal handler. + struct sigaction sa{}; + +// Glibc headers for sa_sigaction trigger this. +#pragma GCC diagnostic push +#if defined(__clang__) +#pragma GCC diagnostic ignored "-Wdisabled-macro-expansion" +#endif + sa.sa_handler = [](int) { g_handler(); }; +#if !PERFETTO_BUILDFLAG(PERFETTO_OS_QNX) + sa.sa_flags = static_cast(SA_RESETHAND | SA_RESTART); +#else // POSIX-compliant + sa.sa_flags = static_cast(SA_RESETHAND); +#endif +#pragma GCC diagnostic pop + sigaction(SIGINT, &sa, nullptr); + sigaction(SIGTERM, &sa, nullptr); +#else + // Do nothing on NaCL and Fuchsia. + ignore_result(handler); +#endif +} + +} // namespace base +} // namespace perfetto +// gen_amalgamated begin source: src/base/event_fd.cc +// gen_amalgamated begin header: include/perfetto/ext/base/event_fd.h +// gen_amalgamated begin header: include/perfetto/ext/base/scoped_file.h +/* + * Copyright (C) 2017 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef INCLUDE_PERFETTO_EXT_BASE_SCOPED_FILE_H_ +#define INCLUDE_PERFETTO_EXT_BASE_SCOPED_FILE_H_ + +// gen_amalgamated expanded: #include "perfetto/base/build_config.h" + +#include + +#if !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) +#include // For DIR* / opendir(). +#endif + +#include + +// gen_amalgamated expanded: #include "perfetto/base/export.h" +// gen_amalgamated expanded: #include "perfetto/base/logging.h" +// gen_amalgamated expanded: #include "perfetto/base/platform_handle.h" + +namespace perfetto { +namespace base { + +namespace internal { +// Used for the most common cases of ScopedResource where there is only one +// invalid value. +template +struct DefaultValidityChecker { + static bool IsValid(T t) { return t != InvalidValue; } +}; +} // namespace internal + +// RAII classes for auto-releasing fds and dirs. +// if T is a pointer type, InvalidValue must be nullptr. Doing otherwise +// causes weird unexpected behaviors (See https://godbolt.org/z/5nGMW4). +template > +class ScopedResource { + public: + using ValidityChecker = Checker; + static constexpr T kInvalid = InvalidValue; + + explicit ScopedResource(T t = InvalidValue) : t_(t) {} + ScopedResource(ScopedResource&& other) noexcept : t_(other.t_) { + other.t_ = InvalidValue; + } + ScopedResource& operator=(ScopedResource&& other) { + reset(other.t_); + other.t_ = InvalidValue; + return *this; + } + T get() const { return t_; } + T operator*() const { return t_; } + explicit operator bool() const { return Checker::IsValid(t_); } + void reset(T r = InvalidValue) { + if (Checker::IsValid(t_)) { + int res = CloseFunction(t_); + if (CheckClose) + PERFETTO_CHECK(res == 0); + } + t_ = r; + } + T release() { + T t = t_; + t_ = InvalidValue; + return t; + } + ~ScopedResource() { reset(InvalidValue); } + + private: + ScopedResource(const ScopedResource&) = delete; + ScopedResource& operator=(const ScopedResource&) = delete; + T t_; +}; + +// Declared in file_utils.h. Forward declared to avoid #include cycles. +int PERFETTO_EXPORT_COMPONENT CloseFile(int fd); + +// Use this for file resources obtained via open() and similar APIs. +using ScopedFile = ScopedResource; +using ScopedFstream = ScopedResource; + +// Use this for resources that are HANDLE on Windows. See comments in +// platform_handle.h +#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) +using ScopedPlatformHandle = ScopedResource; +#else +// On non-windows systems we alias ScopedPlatformHandle to ScopedFile because +// they are really the same. This is to allow assignments between the two in +// Linux-specific code paths that predate ScopedPlatformHandle. +static_assert(std::is_same::value, ""); +using ScopedPlatformHandle = ScopedFile; + +// DIR* does not exist on Windows. +using ScopedDir = ScopedResource; +#endif + +} // namespace base +} // namespace perfetto + +#endif // INCLUDE_PERFETTO_EXT_BASE_SCOPED_FILE_H_ +/* + * Copyright (C) 2018 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef INCLUDE_PERFETTO_EXT_BASE_EVENT_FD_H_ +#define INCLUDE_PERFETTO_EXT_BASE_EVENT_FD_H_ + +// gen_amalgamated expanded: #include "perfetto/base/build_config.h" +// gen_amalgamated expanded: #include "perfetto/base/platform_handle.h" +// gen_amalgamated expanded: #include "perfetto/ext/base/scoped_file.h" + +namespace perfetto { +namespace base { + +// A waitable event that can be used with poll/select. +// This is really a wrapper around eventfd_create with a pipe-based fallback +// for other platforms where eventfd is not supported. +class EventFd { + public: + EventFd(); + ~EventFd(); + EventFd(EventFd&&) noexcept = default; + EventFd& operator=(EventFd&&) = default; + + // The non-blocking file descriptor that can be polled to wait for the event. + PlatformHandle fd() const { return event_handle_.get(); } + + // Can be called from any thread. + void Notify(); + + // Can be called from any thread. If more Notify() are queued a Clear() call + // can clear all of them (up to 16 per call). + void Clear(); + + private: + // The eventfd, when eventfd is supported, otherwise this is the read end of + // the pipe for fallback mode. + ScopedPlatformHandle event_handle_; + +// QNX is specified because it is a non-Linux UNIX platform but it +// still sets the PERFETTO_OS_LINUX flag to be as compatible as possible +// with the Linux build. +#if !PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX_BUT_NOT_QNX) && \ + !PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) && \ + !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) + // On Mac and other non-Linux UNIX platforms a pipe-based fallback is used. + // The write end of the wakeup pipe. + ScopedFile write_fd_; +#endif +}; + +} // namespace base +} // namespace perfetto + +#endif // INCLUDE_PERFETTO_EXT_BASE_EVENT_FD_H_ +// gen_amalgamated begin header: include/perfetto/ext/base/pipe.h +/* + * Copyright (C) 2018 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef INCLUDE_PERFETTO_EXT_BASE_PIPE_H_ +#define INCLUDE_PERFETTO_EXT_BASE_PIPE_H_ + +// gen_amalgamated expanded: #include "perfetto/base/platform_handle.h" +// gen_amalgamated expanded: #include "perfetto/ext/base/scoped_file.h" + +namespace perfetto { +namespace base { + +class Pipe { + public: + enum Flags { + kBothBlock = 0, +#if !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) + kBothNonBlock, + kRdNonBlock, + kWrNonBlock, +#endif + }; + + static Pipe Create(Flags = kBothBlock); + + Pipe(); + Pipe(Pipe&&) noexcept; + Pipe& operator=(Pipe&&); + + ScopedPlatformHandle rd; + ScopedPlatformHandle wr; +}; + +} // namespace base +} // namespace perfetto + +#endif // INCLUDE_PERFETTO_EXT_BASE_PIPE_H_ +/* + * Copyright (C) 2018 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// gen_amalgamated expanded: #include "perfetto/base/build_config.h" + +#include +#include + +#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) +#include + +#include +#elif PERFETTO_BUILDFLAG(PERFETTO_OS_QNX) +#include +#elif PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \ + PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) +#include +#include +#else // Mac, Fuchsia and other non-Linux UNIXes +#include +#endif + +// gen_amalgamated expanded: #include "perfetto/base/logging.h" +// gen_amalgamated expanded: #include "perfetto/ext/base/event_fd.h" +// gen_amalgamated expanded: #include "perfetto/ext/base/pipe.h" +// gen_amalgamated expanded: #include "perfetto/ext/base/utils.h" + +namespace perfetto { +namespace base { + +EventFd::~EventFd() = default; + +#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) +EventFd::EventFd() { + event_handle_.reset( + CreateEventA(/*lpEventAttributes=*/nullptr, /*bManualReset=*/true, + /*bInitialState=*/false, /*bInitialState=*/nullptr)); +} + +void EventFd::Notify() { + if (!SetEvent(event_handle_.get())) // 0: fail, !0: success, unlike UNIX. + PERFETTO_DFATAL("EventFd::Notify()"); +} + +void EventFd::Clear() { + if (!ResetEvent(event_handle_.get())) // 0: fail, !0: success, unlike UNIX. + PERFETTO_DFATAL("EventFd::Clear()"); +} + +#elif PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX_BUT_NOT_QNX) || \ + PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) + +EventFd::EventFd() { + event_handle_.reset(eventfd(/*initval=*/0, EFD_CLOEXEC | EFD_NONBLOCK)); + PERFETTO_CHECK(event_handle_); +} + +void EventFd::Notify() { + const uint64_t value = 1; + ssize_t ret = write(event_handle_.get(), &value, sizeof(value)); + if (ret <= 0 && errno != EAGAIN) + PERFETTO_DFATAL("EventFd::Notify()"); +} + +void EventFd::Clear() { + uint64_t value; + ssize_t ret = + PERFETTO_EINTR(read(event_handle_.get(), &value, sizeof(value))); + if (ret <= 0 && errno != EAGAIN) + PERFETTO_DFATAL("EventFd::Clear()"); +} + +#else + +EventFd::EventFd() { + // Make the pipe non-blocking so that we never block the waking thread (either + // the main thread or another one) when scheduling a wake-up. + Pipe pipe = Pipe::Create(Pipe::kBothNonBlock); + event_handle_ = ScopedPlatformHandle(std::move(pipe.rd).release()); + write_fd_ = std::move(pipe.wr); +} + +void EventFd::Notify() { + const uint64_t value = 1; + ssize_t ret = write(write_fd_.get(), &value, sizeof(uint8_t)); + if (ret <= 0 && errno != EAGAIN) + PERFETTO_DFATAL("EventFd::Notify()"); +} + +void EventFd::Clear() { + // Drain the byte(s) written to the wake-up pipe. We can potentially read + // more than one byte if several wake-ups have been scheduled. + char buffer[16]; + ssize_t ret = + PERFETTO_EINTR(read(event_handle_.get(), &buffer[0], sizeof(buffer))); + if (ret <= 0 && errno != EAGAIN) + PERFETTO_DFATAL("EventFd::Clear()"); +} +#endif + +} // namespace base +} // namespace perfetto +// gen_amalgamated begin source: src/base/file_utils.cc +// gen_amalgamated begin header: include/perfetto/ext/base/file_utils.h +// gen_amalgamated begin header: include/perfetto/base/status.h +/* + * Copyright (C) 2019 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef INCLUDE_PERFETTO_BASE_STATUS_H_ +#define INCLUDE_PERFETTO_BASE_STATUS_H_ + +#include +#include +#include +#include + +// gen_amalgamated expanded: #include "perfetto/base/compiler.h" +// gen_amalgamated expanded: #include "perfetto/base/export.h" +// gen_amalgamated expanded: #include "perfetto/base/logging.h" + +namespace perfetto { +namespace base { + +// Represents either the success or the failure message of a function. +// This can used as the return type of functions which would usually return an +// bool for success or int for errno but also wants to add some string context +// (ususally for logging). +// +// Similar to absl::Status, an optional "payload" can also be included with more +// context about the error. This allows passing additional metadata about the +// error (e.g. location of errors, potential mitigations etc). +class PERFETTO_EXPORT_COMPONENT Status { + public: + Status() : ok_(true) {} + explicit Status(std::string msg) : ok_(false), message_(std::move(msg)) { + PERFETTO_CHECK(!message_.empty()); + } + + // Copy operations. + Status(const Status&) = default; + Status& operator=(const Status&) = default; + + // Move operations. The moved-from state is valid but unspecified. + Status(Status&&) noexcept = default; + Status& operator=(Status&&) = default; + + bool ok() const { return ok_; } + + // When ok() is false this returns the error message. Returns the empty string + // otherwise. + const std::string& message() const { return message_; } + const char* c_message() const { return message_.c_str(); } + + ////////////////////////////////////////////////////////////////////////////// + // Payload Management APIs + ////////////////////////////////////////////////////////////////////////////// + + // Payloads can be attached to error statuses to provide additional context. + // + // Payloads are (key, value) pairs, where the key is a string acting as a + // unique "type URL" and the value is an opaque string. The "type URL" should + // be unique, follow the format of a URL and, ideally, documentation on how to + // interpret its associated data should be available. + // + // To attach a payload to a status object, call `Status::SetPayload()`. + // Similarly, to extract the payload from a status, call + // `Status::GetPayload()`. + // + // Note: the payload APIs are only meaningful to call when the status is an + // error. Otherwise, all methods are noops. + + // Gets the payload for the given |type_url| if one exists. + // + // Will always return std::nullopt if |ok()|. + std::optional GetPayload(std::string_view type_url) const; + + // Sets the payload for the given key. The key should + // + // Will always do nothing if |ok()|. + void SetPayload(std::string_view type_url, std::string value); + + // Erases the payload for the given string and returns true if the payload + // existed and was erased. + // + // Will always do nothing if |ok()|. + bool ErasePayload(std::string_view type_url); + + private: + struct Payload { + std::string type_url; + std::string payload; + }; + + bool ok_ = false; + std::string message_; + std::vector payloads_; +}; + +// Returns a status object which represents the Ok status. +inline Status OkStatus() { + return Status(); +} + +Status ErrStatus(const char* format, ...) PERFETTO_PRINTF_FORMAT(1, 2); + +} // namespace base +} // namespace perfetto + +#endif // INCLUDE_PERFETTO_BASE_STATUS_H_ +/* + * Copyright (C) 2018 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef INCLUDE_PERFETTO_EXT_BASE_FILE_UTILS_H_ +#define INCLUDE_PERFETTO_EXT_BASE_FILE_UTILS_H_ + +#include // For mode_t & O_RDONLY/RDWR. Exists also on Windows. +#include + +#include +#include +#include + +// gen_amalgamated expanded: #include "perfetto/base/build_config.h" +// gen_amalgamated expanded: #include "perfetto/base/export.h" +// gen_amalgamated expanded: #include "perfetto/base/status.h" +// gen_amalgamated expanded: #include "perfetto/ext/base/scoped_file.h" +// gen_amalgamated expanded: #include "perfetto/ext/base/utils.h" + +namespace perfetto { +namespace base { + +#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) +using FileOpenMode = int; +inline constexpr char kDevNull[] = "NUL"; +inline constexpr char kFopenReadFlag[] = "r"; +#else +using FileOpenMode = mode_t; +inline constexpr char kDevNull[] = "/dev/null"; +inline constexpr char kFopenReadFlag[] = "re"; +#endif + +constexpr FileOpenMode kFileModeInvalid = static_cast(-1); + +bool ReadPlatformHandle(PlatformHandle, std::string* out); +bool ReadFileDescriptor(int fd, std::string* out); +bool ReadFileStream(FILE* f, std::string* out); +bool ReadFile(const std::string& path, std::string* out); + +// A wrapper around read(2). It deals with Linux vs Windows includes. It also +// deals with handling EINTR. Has the same semantics of UNIX's read(2). +ssize_t Read(int fd, void* dst, size_t dst_size); + +// Call write until all data is written or an error is detected. +// +// man 2 write: +// If a write() is interrupted by a signal handler before any bytes are +// written, then the call fails with the error EINTR; if it is +// interrupted after at least one byte has been written, the call +// succeeds, and returns the number of bytes written. +ssize_t WriteAll(int fd, const void* buf, size_t count); + +// Copies all data from |fd_in| to |fd_out|. Saves the offset of |fd_in|, +// rewinds it to the beginning, copies the content, and restores the offset. +// |fd_in| can't be a pipe, socket of FIFO. +base::Status CopyFileContents(int fd_in, int fd_out); + +ssize_t WriteAllHandle(PlatformHandle, const void* buf, size_t count); + +ScopedFile OpenFile(const std::string& path, + int flags, + FileOpenMode = kFileModeInvalid); +ScopedFstream OpenFstream(const std::string& path, const std::string& mode); + +// This is an alias for close(). It's to avoid leaking windows.h in headers. +// Exported because ScopedFile is used in the /include/ext API by Chromium +// component builds. +int PERFETTO_EXPORT_COMPONENT CloseFile(int fd); + +bool FlushFile(int fd); + +// Returns true if mkdir succeeds, false if it fails (see errno in that case). +bool Mkdir(const std::string& path); + +// Calls rmdir() on UNIX, _rmdir() on Windows. +bool Rmdir(const std::string& path); + +// Wrapper around access(path, F_OK). +bool FileExists(const std::string& path); + +// Gets the extension for a filename. If the file has two extensions, returns +// only the last one (foo.pb.gz => .gz). Returns empty string if there is no +// extension. +std::string GetFileExtension(const std::string& filename); + +// Puts the path to all files under |dir_path| in |output|, recursively walking +// subdirectories. File paths are relative to |dir_path|. Only files are +// included, not directories. Path separator is always '/', even on windows (not +// '\'). +base::Status ListFilesRecursive(const std::string& dir_path, + std::vector& output); + +// Sets |path|'s owner group to |group_name| and permission mode bits to +// |mode_bits|. +base::Status SetFilePermissions(const std::string& path, + const std::string& group_name, + const std::string& mode_bits); + +// Returns the size of the file located at |path|, or nullopt in case of error. +std::optional GetFileSize(const std::string& path); + +// Returns the size of the open file |fd|, or nullopt in case of error. +std::optional GetFileSize(PlatformHandle fd); + +} // namespace base +} // namespace perfetto + +#endif // INCLUDE_PERFETTO_EXT_BASE_FILE_UTILS_H_ +/* + * Copyright (C) 2018 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// gen_amalgamated expanded: #include "perfetto/ext/base/file_utils.h" + +#include +#include + +#include +#include +#include +#include +#include + +// gen_amalgamated expanded: #include "perfetto/base/build_config.h" +// gen_amalgamated expanded: #include "perfetto/base/compiler.h" +// gen_amalgamated expanded: #include "perfetto/base/logging.h" +// gen_amalgamated expanded: #include "perfetto/base/platform_handle.h" +// gen_amalgamated expanded: #include "perfetto/base/status.h" +// gen_amalgamated expanded: #include "perfetto/ext/base/platform.h" +// gen_amalgamated expanded: #include "perfetto/ext/base/scoped_file.h" +// gen_amalgamated expanded: #include "perfetto/ext/base/string_utils.h" +// gen_amalgamated expanded: #include "perfetto/ext/base/utils.h" + +#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) +#include + +#include +#include +#include +#else +#include +#include +#endif + +#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \ + PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) || \ + PERFETTO_BUILDFLAG(PERFETTO_OS_FREEBSD) || \ + PERFETTO_BUILDFLAG(PERFETTO_OS_APPLE) +#define PERFETTO_SET_FILE_PERMISSIONS +#include +#include +#include +#include +#include +#endif + +namespace perfetto { +namespace base { +namespace { +constexpr size_t kBufSize = 2048; + +#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) +// Wrap FindClose to: (1) make the return unix-style; (2) deal with stdcall. +int CloseFindHandle(HANDLE h) { + return FindClose(h) ? 0 : -1; +} + +std::optional ToUtf16(const std::string& str) { + int len = MultiByteToWideChar(CP_UTF8, 0, str.data(), + static_cast(str.size()), nullptr, 0); + if (len < 0) { + return std::nullopt; + } + std::vector tmp; + tmp.resize(static_cast::size_type>(len)); + len = + MultiByteToWideChar(CP_UTF8, 0, str.data(), static_cast(str.size()), + tmp.data(), static_cast(tmp.size())); + if (len < 0) { + return std::nullopt; + } + PERFETTO_CHECK(static_cast::size_type>(len) == + tmp.size()); + return std::wstring(tmp.data(), tmp.size()); +} + +#endif + +} // namespace + +ssize_t Read(int fd, void* dst, size_t dst_size) { + ssize_t ret; + platform::BeforeMaybeBlockingSyscall(); +#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) + ret = _read(fd, dst, static_cast(dst_size)); +#else + ret = PERFETTO_EINTR(read(fd, dst, dst_size)); +#endif + platform::AfterMaybeBlockingSyscall(); + return ret; +} + +bool ReadFileDescriptor(int fd, std::string* out) { + // Do not override existing data in string. + size_t i = out->size(); + + struct stat buf{}; + if (fstat(fd, &buf) != -1) { + if (buf.st_size > 0) + out->resize(i + static_cast(buf.st_size)); + } + + ssize_t bytes_read; + for (;;) { + if (out->size() < i + kBufSize) + out->resize(out->size() + kBufSize); + + bytes_read = Read(fd, &((*out)[i]), kBufSize); + if (bytes_read > 0) { + i += static_cast(bytes_read); + } else { + out->resize(i); + return bytes_read == 0; + } + } +} + +bool ReadPlatformHandle(PlatformHandle h, std::string* out) { +#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) + // Do not override existing data in string. + size_t i = out->size(); + + for (;;) { + if (out->size() < i + kBufSize) + out->resize(out->size() + kBufSize); + DWORD bytes_read = 0; + auto res = ::ReadFile(h, &((*out)[i]), kBufSize, &bytes_read, nullptr); + if (res && bytes_read > 0) { + i += static_cast(bytes_read); + } else { + out->resize(i); + const bool is_eof = res && bytes_read == 0; + auto err = res ? 0 : GetLastError(); + // The "Broken pipe" error on Windows is slightly different than Unix: + // On Unix: a "broken pipe" error can happen only on the writer side. On + // the reader there is no broken pipe, just a EOF. + // On windows: the reader also sees a broken pipe error. + // Here we normalize on the Unix behavior, treating broken pipe as EOF. + return is_eof || err == ERROR_BROKEN_PIPE; + } + } +#else + return ReadFileDescriptor(h, out); +#endif +} + +bool ReadFileStream(FILE* f, std::string* out) { + return ReadFileDescriptor(fileno(f), out); +} + +bool ReadFile(const std::string& path, std::string* out) { + base::ScopedFile fd = base::OpenFile(path, O_RDONLY); + if (!fd) + return false; + + return ReadFileDescriptor(*fd, out); +} + +ssize_t WriteAll(int fd, const void* buf, size_t count) { + size_t written = 0; + while (written < count) { + // write() on windows takes an unsigned int size. + uint32_t bytes_left = static_cast( + std::min(count - written, static_cast(UINT32_MAX))); + platform::BeforeMaybeBlockingSyscall(); + ssize_t wr = PERFETTO_EINTR( + write(fd, static_cast(buf) + written, bytes_left)); + platform::AfterMaybeBlockingSyscall(); + if (wr == 0) + break; + if (wr < 0) + return wr; + written += static_cast(wr); + } + return static_cast(written); +} + +base::Status CopyFileContents(int fd_in, int fd_out) { + off_t original_offset = lseek(fd_in, 0, SEEK_CUR); + if (original_offset == -1) { + return base::ErrStatus( + "Can't get offset in 'fd_in', lseek error: %s (errno: %d)", + strerror(errno), errno); + } + + if (lseek(fd_in, 0, SEEK_SET) == -1) { + return base::ErrStatus( + "Can't change the offset in 'fd_in', lseek error: %s (errno: %d)", + strerror(errno), errno); + } + + auto restore_offset_on_exit = OnScopeExit([fd_in, original_offset] { + // 'lseek' should never fail here, but if it fails, we crash, to prevent + // possible data loss/overwrite in the 'fd_in'. + PERFETTO_CHECK(lseek(fd_in, original_offset, SEEK_SET) >= 0); + }); + + // Use bigger buffer when copy files. + constexpr size_t kCopyFileBufSize = 32 * 1024; // 32KB. + static_assert(kCopyFileBufSize > kBufSize); + // Don't allocate that much memory on stack. + std::vector buffer(kCopyFileBufSize); + for (;;) { + ssize_t bytes_read = Read(fd_in, buffer.data(), buffer.size()); + if (bytes_read == 0) + break; + if (bytes_read < 0) { + return base::ErrStatus("Read failed: %s (errno: %d)", strerror(errno), + errno); + } + ssize_t written = + WriteAll(fd_out, buffer.data(), static_cast(bytes_read)); + if (written != bytes_read) { + return base::ErrStatus("Write failed: %s (errno: %d)", strerror(errno), + errno); + } + } + return base::OkStatus(); +} + +ssize_t WriteAllHandle(PlatformHandle h, const void* buf, size_t count) { +#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) + DWORD wsize = 0; + if (::WriteFile(h, buf, static_cast(count), &wsize, nullptr)) { + return wsize; + } else { + return -1; + } +#else + return WriteAll(h, buf, count); +#endif +} + +bool FlushFile(int fd) { + PERFETTO_DCHECK(fd != 0); +#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \ + PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) + return !PERFETTO_EINTR(fdatasync(fd)); +#elif PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) + return !PERFETTO_EINTR(_commit(fd)); +#else + return !PERFETTO_EINTR(fsync(fd)); +#endif +} + +bool Mkdir(const std::string& path) { +#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) + return _mkdir(path.c_str()) == 0; +#else + return mkdir(path.c_str(), 0755) == 0; +#endif +} + +bool Rmdir(const std::string& path) { +#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) + return _rmdir(path.c_str()) == 0; +#else + return rmdir(path.c_str()) == 0; +#endif +} + +int CloseFile(int fd) { + return close(fd); +} + +ScopedFile OpenFile(const std::string& path, int flags, FileOpenMode mode) { + // If a new file might be created, ensure that the permissions for the new + // file are explicitly specified. + PERFETTO_CHECK((flags & O_CREAT) == 0 || mode != kFileModeInvalid); +#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) + // Always use O_BINARY on Windows, to avoid silly EOL translations. + ScopedFile fd(_open(path.c_str(), flags | O_BINARY, mode)); +#else + // Always open a ScopedFile with O_CLOEXEC so we can safely fork and exec. + ScopedFile fd(open(path.c_str(), flags | O_CLOEXEC, mode)); +#endif + return fd; +} + +ScopedFstream OpenFstream(const std::string& path, const std::string& mode) { + ScopedFstream file; + // On Windows fopen interprets filename using the ANSI or OEM codepage but + // sqlite3_value_text returns a UTF-8 string. To make sure we interpret the + // filename correctly we use _wfopen and a UTF-16 string on windows. + // + // On Windows fopen also open files in the text mode by default, but we want + // to open them in the binary mode, to avoid silly EOL translations (and to be + // consistent with base::OpenFile). So we check the mode first and append 'b' + // mode only when it makes sense. +#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) + std::string s_mode(mode); + // Windows supports non-standard mode extension that sets encoding in text + // mode. If you need to open a FILE* in text mode, use the fopen API directly. + bool is_text_mode = Contains(s_mode, "ccs=") || Contains(s_mode, "t"); + PERFETTO_CHECK(!is_text_mode); + bool is_binary_mode = Contains(s_mode, 'b'); + if (!is_binary_mode) + s_mode += 'b'; + + auto w_path = ToUtf16(path); + auto w_mode = ToUtf16(s_mode); + if (w_path && w_mode) { + file.reset(_wfopen(w_path->c_str(), w_mode->c_str())); + } +#else + file.reset(fopen(path.c_str(), mode.c_str())); +#endif + return file; +} + +bool FileExists(const std::string& path) { +#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) + return _access(path.c_str(), 0) == 0; +#else + return access(path.c_str(), F_OK) == 0; +#endif +} + +// Declared in base/platform_handle.h. +int ClosePlatformHandle(PlatformHandle handle) { +#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) + // Make the return value UNIX-style. + return CloseHandle(handle) ? 0 : -1; +#else + return close(handle); +#endif +} + +base::Status ListFilesRecursive(const std::string& dir_path, + std::vector& output) { + std::string root_dir_path = dir_path; + if (root_dir_path.back() == '\\') { + root_dir_path.back() = '/'; + } else if (root_dir_path.back() != '/') { + root_dir_path.push_back('/'); + } + + // dir_queue contains full paths to the directories. The paths include the + // root_dir_path at the beginning and the trailing slash at the end. + std::deque dir_queue; + dir_queue.push_back(root_dir_path); + + while (!dir_queue.empty()) { + const std::string cur_dir = std::move(dir_queue.front()); + dir_queue.pop_front(); +#if PERFETTO_BUILDFLAG(PERFETTO_OS_NACL) + return base::ErrStatus("ListFilesRecursive not supported yet"); +#elif PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) + std::string glob_path = cur_dir + "*"; + // + 1 because we also have to count the NULL terminator. + if (glob_path.length() + 1 > MAX_PATH) + return base::ErrStatus("Directory path %s is too long", dir_path.c_str()); + WIN32_FIND_DATAA ffd; + + base::ScopedResource + hFind(FindFirstFileA(glob_path.c_str(), &ffd)); + if (!hFind) { + // For empty directories, there should be at least one entry '.'. + // If FindFirstFileA returns INVALID_HANDLE_VALUE, this means directory + // couldn't be accessed. + return base::ErrStatus("Failed to open directory %s", cur_dir.c_str()); + } + do { + if (strcmp(ffd.cFileName, ".") == 0 || strcmp(ffd.cFileName, "..") == 0) + continue; + if (ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) { + std::string subdir_path = cur_dir + ffd.cFileName + '/'; + dir_queue.push_back(subdir_path); + } else { + const std::string full_path = cur_dir + ffd.cFileName; + PERFETTO_CHECK(full_path.length() > root_dir_path.length()); + output.push_back(full_path.substr(root_dir_path.length())); + } + } while (FindNextFileA(*hFind, &ffd)); +#else + ScopedDir dir = ScopedDir(opendir(cur_dir.c_str())); + if (!dir) { + return base::ErrStatus("Failed to open directory %s", cur_dir.c_str()); + } + for (auto* dirent = readdir(dir.get()); dirent != nullptr; + dirent = readdir(dir.get())) { + if (strcmp(dirent->d_name, ".") == 0 || + strcmp(dirent->d_name, "..") == 0) { + continue; + } + struct stat dirstat; + std::string full_path = cur_dir + dirent->d_name; + PERFETTO_CHECK(stat(full_path.c_str(), &dirstat) == 0); + if (S_ISDIR(dirstat.st_mode)) { + dir_queue.push_back(full_path + '/'); + } else if (S_ISREG(dirstat.st_mode)) { + PERFETTO_CHECK(full_path.length() > root_dir_path.length()); + output.push_back(full_path.substr(root_dir_path.length())); + } + } +#endif + } + return base::OkStatus(); +} + +std::string GetFileExtension(const std::string& filename) { + auto ext_idx = filename.rfind('.'); + if (ext_idx == std::string::npos) + return std::string(); + return filename.substr(ext_idx); +} + +base::Status SetFilePermissions(const std::string& file_path, + const std::string& group_name_or_id, + const std::string& mode_bits) { +#ifdef PERFETTO_SET_FILE_PERMISSIONS + PERFETTO_CHECK(!file_path.empty()); + PERFETTO_CHECK(!group_name_or_id.empty()); + + // Default |group_id| to -1 for not changing the group ownership. + gid_t group_id = static_cast(-1); + auto maybe_group_id = base::StringToUInt32(group_name_or_id); + if (maybe_group_id) { // A numerical group ID. + group_id = *maybe_group_id; + } else { // A group name. + struct group* file_group = nullptr; + // Query the group ID of |group|. + do { + file_group = getgrnam(group_name_or_id.c_str()); + } while (file_group == nullptr && errno == EINTR); + if (file_group == nullptr) { + return base::ErrStatus("Failed to get group information of %s ", + group_name_or_id.c_str()); + } + group_id = file_group->gr_gid; + } + + if (PERFETTO_EINTR(chown(file_path.c_str(), geteuid(), group_id))) { + return base::ErrStatus("Failed to chown %s ", file_path.c_str()); + } + + // |mode| accepts values like "0660" as "rw-rw----" mode bits. + auto mode_value = base::StringToInt32(mode_bits, 8); + if (!(mode_bits.size() == 4 && mode_value.has_value())) { + return base::ErrStatus( + "The chmod mode bits must be a 4-digit octal number, e.g. 0660"); + } + if (PERFETTO_EINTR( + chmod(file_path.c_str(), static_cast(mode_value.value())))) { + return base::ErrStatus("Failed to chmod %s", file_path.c_str()); + } + return base::OkStatus(); +#else + base::ignore_result(file_path); + base::ignore_result(group_name_or_id); + base::ignore_result(mode_bits); + return base::ErrStatus( + "Setting file permissions is not supported on this platform"); +#endif +} + +std::optional GetFileSize(const std::string& file_path) { +#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) + // This does not use base::OpenFile to avoid getting an exclusive lock. + base::ScopedPlatformHandle fd( + CreateFileA(file_path.c_str(), FILE_READ_ATTRIBUTES, FILE_SHARE_READ, + nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr)); +#else + base::ScopedFile fd(base::OpenFile(file_path, O_RDONLY | O_CLOEXEC)); +#endif + if (!fd) { + return std::nullopt; + } + return GetFileSize(*fd); +} + +std::optional GetFileSize(PlatformHandle fd) { +#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) + LARGE_INTEGER file_size; + file_size.QuadPart = 0; + if (!GetFileSizeEx(fd, &file_size)) { + return std::nullopt; + } + static_assert(sizeof(decltype(file_size.QuadPart)) <= sizeof(uint64_t)); + return static_cast(file_size.QuadPart); +#else + struct stat buf{}; + if (fstat(fd, &buf) == -1) { + return std::nullopt; + } + static_assert(sizeof(decltype(buf.st_size)) <= sizeof(uint64_t)); + return static_cast(buf.st_size); +#endif +} + +} // namespace base +} // namespace perfetto +// gen_amalgamated begin source: src/base/getopt_compat.cc +// gen_amalgamated begin header: include/perfetto/ext/base/getopt_compat.h +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef INCLUDE_PERFETTO_EXT_BASE_GETOPT_COMPAT_H_ +#define INCLUDE_PERFETTO_EXT_BASE_GETOPT_COMPAT_H_ + +#include // For std::nullptr_t + +// No translation units other than base/getopt.h and getopt_compat_unittest.cc +// should directly include this file. Use base/getopt.h instead. + +namespace perfetto { +namespace base { +namespace getopt_compat { + +// A tiny getopt() replacement for Windows, which doesn't have . +// This implementation is based on the subset of features that we use in the +// Perfetto codebase. It doesn't even try to deal with the full surface of GNU's +// getopt(). +// Limitations: +// - getopt_long_only() is not supported. +// - optional_argument is not supported. That is extremely subtle and caused us +// problems in the past with GNU's getopt. +// - It does not reorder non-option arguments. It behaves like MacOS getopt, or +// GNU's when POSIXLY_CORRECT=1. +// - Doesn't expose optopt or opterr. +// - option.flag and longindex are not supported and must be nullptr. + +enum { + no_argument = 0, + required_argument = 1, +}; + +struct option { + const char* name; + int has_arg; + std::nullptr_t flag; // Only nullptr is supported. + int val; +}; + +extern char* optarg; +extern int optind; +extern int optopt; +extern int opterr; + +int getopt_long(int argc, + char** argv, + const char* shortopts, + const option* longopts, + std::nullptr_t /*longindex is not supported*/); + +int getopt(int argc, char** argv, const char* shortopts); + +} // namespace getopt_compat +} // namespace base +} // namespace perfetto + +#endif // INCLUDE_PERFETTO_EXT_BASE_GETOPT_COMPAT_H_ +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// gen_amalgamated expanded: #include "perfetto/ext/base/getopt_compat.h" + +#include +#include +#include + +#include + +// gen_amalgamated expanded: #include "perfetto/base/logging.h" + +namespace perfetto { +namespace base { +namespace getopt_compat { + +char* optarg = nullptr; +int optind = 0; +int optopt = 0; +int opterr = 1; + +namespace { + +char* nextchar = nullptr; + +const option* LookupLongOpt(const std::vector